Operatori - e -= - sottrazione (meno)

  • Articolo

Gli operatori - e -= sono supportati dai tipi numerici integrali e in virgola mobile predefiniti e delegati.

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

Rimozione di delegati

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

  • Se entrambi gli operandi sono diversi da Null e l'elenco chiamate dell'operando di destra è un sottoelenco contiguo dell'elenco chiamate dell'operando di sinistra, il risultato dell'operazione è un nuovo elenco chiamate ottenuto rimuovendo le voci dell'operando di destra dall'elenco di chiamate dell'operando di sinistra. Se l'elenco dell'operando di destra corrisponde a più sottoelenchi contigui nell'elenco dell'operando di sinistra, viene rimosso solo il sottoelenco corrispondente più 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 sottoelenco contiguo dell'elenco chiamate dell'operando di sinistra, il risultato dell'operazione è l'operando di sinistra. La rimozione di un delegato che non fa parte del delegato multicast, ad esempio, non produce alcun risultato 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 del delegato, vengono confrontate le istanze del delegato. I delegati prodotti dalla valutazione di espressioni lambda identiche, ad esempio, non sono uguali. Per altre informazioni sull'uguaglianza dei delegati, vedere la sezione Delegare gli operatori di uguaglianza dell'articolo Specifiche del linguaggio C#.

  • Se l'operando di sinistra è 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, usare l'operatore +.

Per altre informazioni sui tipi delegate, vedere Delegati.

Operatore di assegnazione di sottrazione -=

Un'espressione che usa l'operatore -=, ad esempio

x -= y

equivale a

x = x - y

con la differenza che x viene valutato una sola volta.

Nell'esempio seguente viene illustrato l'uso 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

È anche possibile usare l'operatore -= per specificare un metodo del gestore eventi quando si elimina la sottoscrizione a un evento. Per altre informazioni, vedere Come iscriversi agli eventi e annullare l'iscrizione.

Overload degli operatori

Un tipo definito dall'utente può eseguire l'overload dell'operatore -. Quando viene eseguito l'overload di un operatore - binario, viene eseguito in modo implicito anche l'overload dell'operatore -=. Un tipo definito dall'utente non può eseguire l'overload dell'operatore -= in modo esplicito.

Specifiche del linguaggio C#

Per altre informazioni, vedere le sezioni Operatore meno unario e Operatore di sottrazione di Specifiche del linguaggio C#.

Vedi anche