Partilhar via

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

Os tipos de delegado incorporados e os tipos numéricos integrais e de ponto flutuante suportam todos os - operadores e .-=

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em versões preliminares públicas para a próxima versão da linguagem.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

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 devolve uma instância de delegado que é calculada da seguinte forma:

  • Se ambos os operandos não null estiverem e a lista de invocações do operando direito for uma sublista contígua própria da lista de invocações do operando da mão esquerda, o resultado da operação é uma nova lista de invocações que se obtém ao remover as entradas do operando direito da lista de invocação do operando da mão esquerda. Se a lista do operando da direita coincidir com múltiplas sublistas contíguas na lista do operando da esquerda, a operação remove apenas a sublista correspondente mais à direita. 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 que utiliza o -= operador, como

x -= y

É equivalente a

x = x - y

Só que x só é avaliada uma vez.

O exemplo seguinte demonstra como usar o -= 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 sobrecarregas um operador binário - , também sobrecarregas implicitamente o -= operador. A partir de C# 14, um tipo definido pelo utilizador pode explicitamente sobrecarregar o -= operador para proporcionar 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