Condividi tramite

Operatori - e -= - sottrazione (meno)

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

Il riferimento al linguaggio C# documenta la versione rilasciata più di recente del linguaggio C#. Contiene anche la documentazione iniziale per le funzionalità nelle versioni di anteprima pubblica per la prossima versione del linguaggio di programmazione.

La documentazione identifica tutte le funzionalità introdotte nelle ultime tre versioni della lingua o nelle anteprime pubbliche correnti.

Suggerimento

Per trovare quando una funzionalità è stata introdotta per la prima volta in C#, vedere l'articolo sulla cronologia delle versioni del linguaggio C#.

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 null sono e l'elenco chiamate dell'operando di destra è un elenco secondario contiguo appropriato 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 chiamate dell'operando sinistro. Se l'elenco dell'operando di destra corrisponde a più sottoliste contigue nell'elenco dell'operando di sinistra, l'operazione rimuove 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 come usare l'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 si esegue l'overload di un operatore binario - , si esegue anche l'overload implicito dell'operatore -= . 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