Compartilhar via

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

Todos os tipos de delegado internos e tipos numéricos integrais e de ponto flutuante dão suporte aos operadores e -= aos - operadores.

A linguagem C# faz referência a documentos da versão mais recentemente lançada da linguagem C#. Ele também contém a documentação inicial para funcionalidades em pré-visualizações públicas para o próximo lançamento do idioma.

A documentação identifica qualquer recurso introduzido pela primeira vez nas três últimas versões do idioma ou nas versões prévias públicas atuais.

Dica

Para descobrir quando um recurso foi introduzido pela primeira vez em C#, consulte o artigo sobre o histórico de versão da linguagem C#.

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 null estiverem 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 que você obtém 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, a operação removerá apenas a sublista mais à direita correspondente. 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 que usa o -= operador, como

x -= y

É equivalente a

x = x - y

Exceto que x é avaliado apenas uma vez.

O exemplo a seguir 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 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. Ao sobrecarregar um operador binário - , você também sobrecarrega implicitamente o -= operador. 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

  • Last updated on