Partilhar via

- e -= operadores - subtração (menos)

Os tipos numéricos integrais e de ponto flutuante, assim como os tipos delegados, todos suportam os operadores - e -=.

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

Remoção do delegado

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

  • Se ambos os operandos não forem nulos e a lista de invocação do operando direito for uma sublista contígua adequada da lista de invocação do operando esquerdo, o resultado da operação será uma nova lista de invocação obtida removendo as entradas do operando direito da lista de invocação do operando esquerdo. Se a lista do operando direito corresponder a várias sublistas contíguas na lista do operando esquerdo, 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 direito não for uma sublista contígua adequada da lista de invocação do operando esquerdo, o resultado da operação será o operando esquerdo. Por exemplo, remover um delegado que não faz parte do delegado multicast não tem efeito e o resultado é que 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 delegadas são comparadas. Por exemplo, os delegados que são produzidos a partir da avaliação de expressões lambda idênticas não são iguais. Para obter mais informações sobre igualdade de delegação, consulte a seção Operadores de igualdade de delegados da especificação de linguagem C#.

  • Caso o operando à esquerda seja 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 delegados, consulte Delegados.

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

Uma expressão usando o operador -=, como

x -= y

É equivalente a

x = x - y

Só que x só é avaliada 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 para remover quando você cancelar a assinatura de um evento. Para obter mais informações, consulte Como se inscrever e cancelar a assinatura de eventos.

Capacidade de sobrecarga do operador

Um tipo definido pelo usuário pode sobrecarregar o operador -. Quando um operador de - binário está sobrecarregado, o operador -= também está implicitamente sobrecarregado. 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 Operador menos unário e Operador de subtração da especificação da linguagem C#. Para obter mais informações sobre como sobrecarregar os operadores de atribuição composta em C# 14 e posteriores, consulte a especificação do recurso de atribuição composta definida pelo usuário .

Ver também

  • Last updated on