Compartilhar via

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

Os tipos numéricos integrados integral e ponto flutuante e os tipos delegados são compatíveis com os operadores - e -=.

Para obter informações sobre o operador aritmético -, consulte as seções Operadores unários de adição e subtração 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 delegada calculada da seguinte maneira:

  • Se ambos os operandos não forem nulos e a lista de invocação do operando à direita for uma sublista contígua adequada da lista de invocação do operando à esquerda, o resultado da operação será uma nova lista de invocação obtida removendo 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 adequada da lista de invocação do operando esquerdo, 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 obter mais informações sobre igualdade de delegados, consulte a seção Operadores de igualdade delegada 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, consulte Delegados.

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

Uma expressão usando 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 usa o -= operador para especificar um método de manipulador de eventos a ser removido ao cancelar a assinatura de um evento. Para obter mais informações, consulte Como inscrever-se em eventos e cancelar a inscrição.

Sobrecarga do operador

Um tipo definido pelo usuário pode sobrecarregar o - operador. Quando um operador binário - é sobrecarregado, o -= operador também é sobrecarregado implicitamente. A partir do C# 14, um tipo definido pelo usuário pode sobrecarregar explicitamente o -= operador para fornecer uma implementação mais eficiente. Normalmente, um tipo sobrecarrega o -= operador porque o valor pode ser atualizado no local, em vez de alocar uma nova instância para armazenar o resultado da subtração. Se um tipo não fornecer uma sobrecarga explícita, o compilador gerará a sobrecarga implícita.

Especificação da linguagem C#

Para obter mais informações, consulte as seções do operador Unary minus e do operador subtração da especificação da linguagem C#. Para obter mais informações sobre como sobrecarregar os operadores de atribuição composta no C# 14 e posterior, consulte a especificação do recurso de atribuição composta definida pelo usuário .

Consulte também