Compartir a través de

- y -= operadores - resta (menos)

Los tipos de delegadointegrados y los tipos numéricos enteros y de punto flotante admiten todos los - operadores y -= .

La documentación de referencia del lenguaje C# cubre la versión más reciente publicada del lenguaje C#. También contiene documentación inicial sobre las características de las versiones preliminares públicas de la próxima versión del lenguaje.

La documentación identifica cualquier característica introducida por primera vez en las últimas tres versiones del idioma o en las versiones preliminares públicas actuales.

Sugerencia

Para buscar cuándo se introdujo por primera vez una característica en C#, consulte el artículo sobre el historial de versiones del lenguaje C#.

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

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

  • Si ambos operandos no null son y la lista de invocación del operando derecho es una sublista contigua adecuada de la lista de invocación del operando izquierdo, el resultado de la operación es una nueva lista de invocación que obtiene quitando las entradas del operando derecho de la lista de invocación del operando izquierdo. Si la lista del operando derecho coincide con varias sublists contiguas en la lista del operando izquierdo, la operación quita solo la sublist 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 asignación de resta -=

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 cómo usar el -= 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 . Al sobrecargar un operador binario - , también sobrecarga implícitamente el -= operador. 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

  • Last updated on