Condividi tramite

Operatori - e -= - sottrazione (meno)

I tipi numerici integrali e a virgola mobile predefiniti e i tipi delegate supportano tutti gli operatori - e -=.

Per informazioni sull'operatore aritmetico - , vedere le sezioni Operatori unari più e meno eOperatore sottrazione - dell'articolo Operatori aritmetici .

Rimozione del delegato

Per gli operandi dello stesso tipo delegato , l'operatore restituisce un'istanza - del delegato calcolata come segue:

  • Se entrambi gli operandi non sono nulli e l'elenco di chiamate dell'operando a destra è un sottoinsieme contiguo corretto dell'elenco di chiamate dell'operando a sinistra, il risultato dell'operazione è un nuovo elenco di chiamate ottenuto eliminando le voci dell'operando a destra dall'elenco di chiamate dell'operando a sinistra. Se l'elenco dell'operando di destra corrisponde a più sottoliste contigue nell'elenco dell'operando di sinistra, viene rimosso solo l'elenco secondario più corrispondente a destra. Se la rimozione restituisce un elenco vuoto, il risultato è 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 l'elenco chiamate dell'operando di destra non è un elenco secondario contiguo appropriato dell'elenco chiamate dell'operando di sinistra, il risultato dell'operazione è l'operando di sinistra. Ad esempio, la rimozione di un delegato che non appartiene al delegato multicast non ha alcun effetto e il delegato multicast rimane invariato.

    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

    L'esempio precedente dimostra anche che, durante la rimozione dei delegati, le istanze dei delegati vengono confrontate. Ad esempio, i delegati che risultano dalla valutazione di espressioni lambda identiche non sono considerati uguali. Per ulteriori informazioni sull'uguaglianza dei delegati, vedere la sezione operatori di uguaglianza dei delegati della specifica del linguaggio C#.

  • Se l'operando sinistro è null, il risultato dell'operazione è null. Se l'operando di destra è null, il risultato dell'operazione è l'operando di sinistra.

    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

Per combinare i delegati, utilizzare l'operatore +.

Per maggiori informazioni sui tipi di delegati, vedere Delegati.

Operatore di assegnazione sottrazione -=

Espressione che usa l'operatore -=, ad esempio

x -= y

Equivale a

x = x - y

Ad eccezione del fatto che x viene valutato una sola volta.

Nell'esempio seguente viene illustrato l'utilizzo dell'operatore -=:

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

Si usa anche l'operatore -= per specificare un metodo del gestore eventi da rimuovere quando si annulla la sottoscrizione a un evento. Per altre informazioni, vedere Come sottoscrivere e annullare la sottoscrizione agli eventi.

Sovraccaricabilità degli operatori

Un tipo definito dall'utente può sovraccaricare l'operatore -. Quando un operatore binario - è sovraccaricato, l'operatore -= è anche sovraccaricato implicitamente. A partire da C# 14, un tipo definito dall'utente può eseguire in modo esplicito l'overload dell'operatore -= per fornire un'implementazione più efficiente. In genere, un tipo esegue l'overload dell'operatore -= perché il valore può essere aggiornato sul posto, anziché allocare una nuova istanza per archiviare il risultato della sottrazione. Se un tipo non fornisce un overload esplicito, il compilatore genera l'overload implicito.

Specificazione del linguaggio C#

Per altre informazioni, vedere le sezioni Operatore unario meno e Operatore sottrazione della specifica del linguaggio C#. Per altre informazioni sull'overload degli operatori di assegnazione composta in C# 14 e versioni successive, vedere la specifica della funzionalità di assegnazione composta definita dall'utente .

Vedere anche

  • Last updated on