Operadores - and -= – subtração (menos)

  • Artigo

Os operadores -e -= são compatíveis com os tipos numéricos integrais e flutuantes internos e os tipos delegados.

Para obter informações sobre o operador - aritmético, consulte as seções Operadores de adição e subtração unários e Operador de subtração - do artigo Operadores aritméticos.

Remoção de delegado

Para operandos do mesmo tipo delegado, o operador - retorna uma instância de delegado que é calculada da seguinte maneira:

  • Se ambos os operandos forem não nulos e a lista de invocação do operando à direita for uma sublista contígua apropriada da lista de invocação do operando à esquerda, o resultado da operação será uma nova lista de invocação obtida removendo-se as entradas do operando à direita da lista de invocação do operando à esquerda. Se a lista do operando à direita corresponder a várias sublistas contíguas na lista do operando à esquerda, somente a sublista correspondente mais à direita será removida. Se a remoção resultar em uma lista vazia, o resultado será 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

  • Se a lista de invocação do operando à direita não for uma sublista contígua apropriada da lista de invocação do operando à esquerda, o resultado da operação será o operando à esquerda. Por exemplo, a remoção de um delegado que não faz parte do delegado multicast não tem consequências, e o delegado multicast permanece inalterado.

    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

    O exemplo anterior também demonstra que, durante a remoção de delegados, as instâncias de delegado são comparadas. Por exemplo, delegados produzidos pela avaliação de expressões lambda idênticas não são iguais. Para saber mais sobre a igualdade de delegados, confira a seção Operadores de igualdade de delegados da Especificação da linguagem C#.

  • Se o operando à esquerda for null, o resultado da operação será null. Se o operando à direita for null, o resultado da operação será o operando à esquerda.

    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

Para combinar delegados, use o operador +.

Para obter mais informações sobre tipos de delegado, veja Delegados.

Operador de atribuição de subtração -=

Uma expressão que usa o operador -=, como

x -= y

é equivalente a

x = x - y

exceto que x é avaliado apenas uma vez.

O exemplo a seguir demonstra o uso do operador -=:

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

Você também usará o operador -= para especificar um método de manipulador de eventos a remover ao cancelar a assinatura de um evento. Para obter mais informações, confira Como assinar e cancelar a assinatura de eventos.

Capacidade de sobrecarga do operador

Um tipo definido pelo usuário pode sobrecarregar o operador -. Quando um operador - binário é sobrecarregado, o operador -= também é implicitamente sobrecarregado. Um tipo definido pelo usuário não pode sobrecarregar explicitamente o operador -=.

Especificação da linguagem C#

Para obter mais informações, veja as seções Operador de subtração unário e Operador de subtração da Especificação de linguagem C#.

Confira também