Compartir vía

- y -= operadores - resta (menos)

  • Artículo

Los operadores - y -= son compatibles con los tipos numéricos enteros y de punto flotante, y los tipos delegados.

Para obtener información sobre el operador aritmético -, consulte las secciones correspondientes a los operadores unarios más y menos y al operador de resta (-) del artículo Operadores aritméticos.

Eliminación de delegados

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

  • Si ambos operandos no son nulos y la lista de invocación del operando derecho es una sublista apropiada 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 mediante la eliminación de 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, la eliminación de un delegado que no forma parte del delegado de multidifusión no surte ningún efecto y da como resultado que el delegado de multidifusión no cambie.

    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 acerca de la igualdad de delegados, consulte la sección Operadores de igualdad de delegado 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 más información sobre los tipos de delegado, vea Delegados.

Operador de resta y asignación (-=)

Una expresión que usa el operador -=, como

x -= y

es equivalente a

x = x - y

salvo que x solo se evalúa una vez.

En el siguiente ejemplo 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 -= con el fin de especificar un método de controlador de eventos para eliminar cuando se finaliza la suscripción a un evento. Para obtener más información, vea Procedimiento para suscribir y cancelar la suscripción a eventos.

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 de modo implícito. Un tipo definido por el usuario no puede sobrecargar de forma explícita el operador -=.

Especificación del lenguaje C#

Para más información, consulte las secciones correspondientes al operador unario menos y al operador de resta de Especificación del lenguaje C#.

Consulte también