Perché usare plus + + = per la registrazione degli eventi?

Se mai provi a scrivere qualcosa del tipo:

window.onClick = myHandler;

Si otterrà un errore del compilatore sui gestori di eventi consentiti solo sul lato destro di += o -= . Il team del compilatore C # è stato abbastanza intelligente da riconoscere tale possibilità e renderlo un errore del compilatore.

Gli eventi sono tipi speciali di delegati multi-cast, quindi quindi stai aggiungendo al suo elenco di invocazione quando += un gestore all'evento. In questo caso, penso che abbia più senso avere += e -= per aggiungere o sottrarre i gestori di eventi.

Non sono sicuro di chi abbia insegnato le tue classi OOP, ma non tutto deve essere ridotto a un metodo get / set. .NET ha reso l'accesso al tipo get / set molto più semplice con le proprietà, che includono i metodi get / set in un singolo costrutto.

VB.NET usa una sintassi leggermente diversa per aggiungere e rimuovere eventi che sono più in linea con quello che vuoi. Utilizzano i metodi AddHandler e RemoveHandler per aggiungere o rimuovendo dall'elenco di invocazione dell'evento, sebbene sia un programmatore C #, trovo lo stile VB "a lungo".

Gli eventi sono solo delegati specializzati. Per i delegati, = elimina le registrazioni precedenti. Allo stesso modo + esegue la composizione funzionale, come molti altri linguaggi. Quindi += combina queste operazioni in append funzionale.

Gli eventi si limitano a limitare le altre operazioni, rendendole un po 'meno intuitive dal momento che non vedi da dove provengono.

Risposta semplice: perché no?

Se ti iscrivi al concetto che possono esserci più gestori per lo stesso evento, allora perché non vuoi l'opzione meno dettagliata?

So di essere su un ghiaccio estremamente sottile in disaccordo con il dio C # Eric Lippert, ma mi è sempre sembrata una sintassi molto naturale. Se il tuo linguaggio abituale è Python o un'altra lingua, posso vedere come potrebbe essere meno.

Tuttavia, sostengo il suo punto di vista sul fatto che è piuttosto evidente. Non riesco a pensare a nessun'altra parte nella lingua in cui sei costretto a usare questa sintassi.

In C #, hai campi e hai anche proprietà, che sono fondamentalmente campi incapsulati. Le proprietà sono comunemente implementate usando i campi (e la lingua ha una scorciatoia per farlo succintamente), ma non è necessario.

Quindi, puoi scrivere entrambi:

o.Field = 42;
o.Property = 42;

Ma quest'ultimo in realtà compila per una chiamata a un metodo setter:

o.set_Property(42);

Un'altra differenza tra campi e proprietà è che le proprietà non consentono alcune operazioni, come l'utilizzo di ref .

È simile a delegati ed eventi: gli eventi sono campi delegati incapsulati. Gli eventi vengono comunemente implementati utilizzando i campi delegati (e la lingua ha una scorciatoia per farlo in modo succinto), ma non è necessario.

Inoltre, puoi scrivere entrambi:

o.DelegateField += Handler;
o.Event += Handler;

Ma quest'ultimo in realtà si compila in una chiamata a un metodo di aggiunta:

o.add_Event(Handler);

Un'altra differenza è che gli eventi non ti consentono la maggior parte delle operazioni, come l'assegnazione o il richiamo di esse (ad eccezione del richiamo di eventi di tipo campo dalla stessa classe dichiarante).

Quindi, ora la domanda è: perché puoi usare += con i campi delegati? È perché puoi utilizzare + per combinare i delegati. Ciò significa che o.DelegateField += Handler; è solo una scorciatoia per o.DelegateField = o.DelegateField + Handler; .

Con gli eventi, non puoi leggere o assegnarli a loro, quindi la sintassi di += di stenografia è l'unica opzione.