Compartir a través de

- y -= operadores - resta (menos)

Los tipos numéricos integrales y de punto flotante incorporados y los tipos delegados admiten los operadores - y -=.

Para obtener información sobre el operador aritmético, consulte las secciones Operadores - y Operador de resta: del artículo Operadores aritméticos.

Eliminación de delegados

Para los operadores del mismo tipo de delegado, el operador - devuelve una instancia de delegado que se determina de la siguiente manera:

  • Si ambos operandos no son nulos y la lista de invocación del operando derecho es una sublista adecuada y contigua de la lista de invocación del operando izquierdo, el resultado de la operación es una nueva lista de invocación que se obtiene eliminando las entradas del operando derecho de la lista de invocación del operando izquierdo. Si la lista del operando derecho coincide con varias sublistas contiguas en la lista del operando izquierdo, se quita solo la sublista coincidente más a la derecha. Si la eliminación da como resultado una lista vacía, el resultado es 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

  • Si la lista de invocación del operando derecho no es una sublista apropiada contigua de la lista de invocación del operando izquierdo, el resultado de la operación es el operando izquierdo. Por ejemplo, eliminar un delegado que no forme parte del delegado de multidifusión no tiene ningún efecto y el delegado de multidifusión permanece sin cambios.

    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

    El ejemplo anterior también demuestra que, durante la eliminación de delegados, se comparan las instancias de delegados. Por ejemplo, los delegados que se producen de la evaluación de expresiones lambda idénticas no son iguales. Para obtener más información sobre la igualdad de delegados, consulte la sección Operadores de igualdad de delegados de la especificación del lenguaje C#.

  • Si el operando izquierdo es null, el resultado de la operación es null. Si el operando derecho es null, el resultado de la operación es el operando izquierdo.

    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, utilice el operador +.

Para obtener más información sobre los tipos de delegado, vea Delegados.

Operador de resta y asignación (-=)

Expresión que usa el -= operador , como

x -= y

Es equivalente a

x = x - y

Excepto que x solo se evalúe una vez.

En el ejemplo siguiente se muestra el uso del 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

También se usa el -= operador para especificar un método de controlador de eventos que se va a quitar al cancelar la suscripción de un evento. Para obtener más información, consulte Cómo suscribirse a eventos y cancelar la suscripción.

Posibilidad de sobrecarga del operador

Un tipo definido por el usuario puede sobrecargar el - operador . Cuando se sobrecarga un operador binario - , el -= operador también se sobrecarga implícitamente. A partir de C# 14, un tipo definido por el usuario puede sobrecargar explícitamente al -= operador para proporcionar una implementación más eficaz. Normalmente, un tipo sobrecarga el -= operador porque el valor se puede actualizar en su lugar, en lugar de asignar una nueva instancia para almacenar el resultado de la resta. Si un tipo no proporciona una sobrecarga explícita, el compilador genera la sobrecarga implícita.

Especificación del lenguaje C#

Para obtener más información, consulte las secciones Operador unario menos y Operador resta de la especificación del lenguaje C#. Para obtener más información sobre cómo sobrecargar los operadores de asignación compuesta en C# 14 y versiones posteriores, consulte la especificación de características de asignación compuesta definida por el usuario .

Consulte también