‫Va bene, quindi in questa lezione imparerai a conoscere i delegati e gli eventi multicast.
‫Quindi cerchiamo prima di esplorare il problema.
‫Immagina di sviluppare un videogioco da zero.
‫Il nostro codice è una combinazione di librerie grafiche e audio e la logica per il nostro lettore.
‫Quindi iniziamo a codificarlo.
‫Considera le seguenti semplici classi.
‫Quindi, prima di tutto, abbiamo questa classe di rendering, che all'inizio del gioco vogliamo abilitare il motore di
‫rendering e iniziare a disegnare le immagini.
‫Quindi eseguirà il rendering e quindi inizierà a disegnare elementi visivi.
‫Inoltre, quando il gioco sarà finito, vogliamo fermare il nostro motore di rendering.
‫Quindi abbiamo questo metodo game over che interromperà il motore di rendering.
‫Quindi qui sto solo usando le istruzioni della riga di destra della console.
‫Questo sarebbe, ovviamente, un codice molto più complesso e questo farebbe effettivamente qualcosa.
‫Nel nostro caso.
‫Stiamo solo cercando di capire il concetto di delegati multicast e di eventi.
‫Ecco perché lo mostreremo semplicemente tramite un'istruzione in linea rossa sulla console.
‫Quindi questa è la nostra classe di rendering.
‫Ora diamo un'occhiata alla nostra classe di sistemi audio.
‫Quindi qui nel sistema audio, abbiamo anche questo metodo di gioco delle freccette, che avvierà semplicemente il sistema audio e riprodurrà
‫un po' di audio.
‫E poi abbiamo il metodo game over, che sostanzialmente fermerà il sistema audio.
‫E infine, abbiamo un giocatore e il giocatore ha un nome giocatore e abbiamo questo semplice costruttore in cui
‫impostiamo quel nome in base a ciò che è stato passato all'oggetto quando è stato creato.
‫E hai anche il gioco iniziale e i metodi game over.
‫OK, quindi questo genererà il giocatore con un'idea e questo rimuoverà semplicemente il
‫giocatore con quel particolare ID che abbiamo assegnato come nome del giocatore.
‫OK, quindi queste sono le nostre tre classi e le farò piuttosto semplice con queste.
‫Quindi andiamo avanti e passiamo al nostro metodo principale.
‫Quindi all'interno del nostro metodo principale, ora creeremo oggetti di quei sistemi.
‫Quindi prima del sistema audio e poi del motore di rendering.
‫Quindi molto semplice, solo oggetti semplici qui.
‫E poi creiamo anche due giocatori con l'ID.
‫Quindi abbiamo questo giocatore, uno che è Duco, e poi il giocatore due, che sarà il doggle Silva.
‫Quindi dobbiamo avviare il nostro motore di rendering, il nostro sistema audio e supportare i giocatori chiamando il metodo di
‫avvio del gioco da ciascuna classe.
‫Quindi facciamolo.
‫E lo farò in questo modo, quindi dirò solo che il sistema audio che avvia il motore di rendering del gioco non
‫esegue il gameplay uno e il giocatore avvia il gioco ciascuno.
‫E poi diciamo solo che il gioco è in esecuzione.
‫Premi un tasto qualsiasi per terminare il gioco.
‫Quindi quello che vogliamo fare ora è sostanzialmente terminare il gioco una volta che il giocatore deve premere il pulsante.
‫OK, quindi sarebbe ovviamente molto più complesso.
‫Diciamo che il giocatore preme tutti e quattro o nel menu delle opzioni, chiude il gioco, quindi verrà eseguito il
‫campo successivo.
‫Quindi il codice successivo sarebbe, ovviamente, chiamare il sistema audio, quel motore di rendering del metodo game over, quel metodo
‫game over, così come i metodi game over del giocatore un giocatore.
‫OK, quindi prendiamocene cura.
‫Aggiungiamolo anche qui.
‫E a proposito, avremo bisogno di una dichiarazione di lettura perché altrimenti lo spegnerà direttamente.
‫Quindi permettetemi di aggiungere rapidamente una dichiarazione di lettura qui in modo che possiamo effettivamente premere manualmente un tasto per poi
‫spegnere tutto e praticamente il gioco finisce.
‫Quindi andiamo molto velocemente e vediamo cosa succederà.
‫Quindi vediamo che il sistema audio avviato è già in riproduzione, il motore di rendering è avviato.
‫Ora vediamo la grafica e poi vengono generati i giocatori.
‫Quindi giocatore uno e giocatore al nostro posto.
‫Ora il gioco è in esecuzione e possiamo giocarci.
‫E poi, una volta che vogliamo finirlo, premiamo un tasto.
‫Quindi premerò un tasto e vedrai il motore di rendering avviarsi, il sistema audio si fermò e
‫rimuoviamo entrambi i giocatori.
‫Quindi questo è stato un vero sforzo per impostare questo.
‫E immagino che dobbiamo farlo con molte più cose.
‫E potrebbero esserci un paio di cose che potrebbero andare storte.
‫Destra.
‫Quindi diciamo che aggiungiamo più sistemi, quindi questo diventa molto più complesso, quindi possiamo facilmente dimenticare di chiamare il metodo di avvio
‫del gioco o il metodo di fine gioco.
‫O ancora peggio, potremmo chiamare uno di questi metodi due volte, il che potrebbe causare tutti i tipi di
‫problemi e richiederci di inserire molto codice di protezione.
‫Quindi dovremmo davvero assicurarci che questo oggetto sia vivo?
‫Ha chiamato questo metodo o ha dovuto chiamare i metodi della polizia troppo complicati?
‫Ed è qui che i delegati multicast tornano utili.
‫Un delegato multicast è un delegato che funziona come un elenco.
‫Word può memorizzare un riferimento a più di un metodo, e questo è fondamentalmente.
‫Ok, sembra piuttosto complesso, ma costruiamolo e poi probabilmente avrà più senso.
‫Quindi creiamo una classe statica chiamata gestore di eventi di gioco.
‫Così.
‫Va bene, allora andiamo avanti e creiamone uno nuovo.
‫Classe qui.
‫E chiamerò questo gestore di eventi di gioco.
‫Bene, quindi questo gestore di eventi di gioco ora avrà un delegato.
‫Quindi creerò un nuovo delegato chiamato Game Event.
‫Quindi non restituirà nulla, ma sarà un delegato stretto e sarà pubblico, quindi possiamo usarlo
‫al di fuori di questa classe.
‫OK, quindi abbiamo visto come lavorano i delegati in generale.
‫E ora useremo questo delegato per consentirci di aggiungere sostanzialmente più di un evento.
‫Quindi creiamo le due variabili chiamate all'inizio del gioco e alla fine del gioco, e saranno fuori dal tipo di evento di
‫gioco.
‫Quindi saranno fuori dal tipo dei nostri delegati.
‫OK, quindi questo sarà un delegato dell'evento di gioco e questo sarà un delegato dell'evento di gioco.
‫Quindi abbiamo queste due variabili delegate che ora possiamo usare.
‫Quindi torniamo alle nostre tre classi.
‫Passiamo all'inizio del gioco e ai metodi di game over per i delegati on game start e on game over.
‫Inoltre, non è necessario che questi metodi siano pubblici.
‫Quindi passiamo al sistema audio e ora rendiamo privati questi due metodi
‫perché non è necessario esporli poiché utilizzeremo il costruttore del sistema audio per aggiungere o sottoscrivere gli
‫eventi.
‫Quindi qui, il posto migliore per aggiungere i nostri metodi al gioco, i delegati MENAGED, è dall'interno del costruttore
‫stesso.
‫OK, è quello che stiamo facendo qui.
‫E quando un oggetto viene creato, il suo metodo verrà automaticamente aggiunto ai delegati o, in altre
‫parole, si sottoscriveranno a loro.
‫Quindi ciò che accadrà ora è che il nostro gioco iniziale e il nostro metodo di fine partita verranno
‫aggiunti al gestore degli eventi di gioco sul delegato di avvio del gioco.
‫E stiamo usando il segno più uguale qui per dire, OK, vogliamo aggiungere questo metodo a quel delegato multicast.
‫Quindi fondamentalmente ci stiamo iscrivendo e stiamo aspettando che quell'evento venga attivato perché una volta
‫che quell'evento sarà attivato, il nostro metodo verrà chiamato, OK.
‫Quindi la cosa interessante è che ora possiamo fare la stessa cosa con la classe del motore di rendering e la classe del giocatore.
‫Quindi ciò che è importante qui è che sto usando il segno più uguale e non solo il segno uguale, quindi
‫non lo sto assegnando.
‫E vedremo più avanti cosa significherebbe un contratto e cosa farà per noi.
‫Ma qui ne stiamo solo aggiungendo un altro.
‫Metodo al nostro event collector, per così dire, al nostro event manager.
‫OK, quindi sta raccogliendo tutti quegli eventi o metodi che dovrebbe poi eseguire.
‫Quindi è un delegato multicast.
‫Ora, facciamo la stessa cosa con il nostro motore di rendering.
‫Vorrei che lo facessi da solo.
‫Quindi passa il video molto velocemente e prova ad assegnare lo stesso codice o crea lo stesso codice come abbiamo
‫fatto nel sistema audio qui.
‫OK, quindi prima di tutto, mi sono assicurato che i miei metodi fossero privati perché non
‫abbiamo più bisogno di esporli poiché non è necessario, non li chiameremo mai al di fuori di questa classe.
‫Ecco perché è sempre una buona pratica renderli privati.
‫Quello che possiamo chiamare, tuttavia, è il costruttore giusto, quindi possiamo creare un oggetto del nostro motore di
‫rendering poiché è pubblico.
‫Quindi ora possiamo andare avanti e aggiungere il nostro metodo START anche all'avvio in corso del nostro gestore di eventi di gioco.
‫E lo stesso vale per il gioco finito.
‫Quindi anche qui stiamo usando più uguale.
‫Quindi stiamo dicendo che ci stiamo iscrivendo agli eventi on game start e on game over.
‫Quindi in pratica stiamo dicendo che una volta attivato l'evento di avvio del gioco, chiama anche il nostro metodo di avvio del gioco, per
‫favore.
‫Con il nostro intendo che i motori di rendering avviano il metodo di gioco.
‫Quindi chiamerà questo metodo.
‫E ovviamente se il gioco è finito, il metodo game over sarà chiamato questo qui.
‫Ecco come stiamo usando l'approccio ora.
‫Piccola sfida per te.
‫Fai la stessa cosa nella classe giocatore, per favore.
‫OK, quindi prima di tutto, spero che tu passi e, beh, non ho intenzione di assicurarmi che questi due metodi siano privati perché
‫nessuno dovrebbe chiamare il metodo di inizio partita e il metodo di fine gioco dall'esterno di
‫esso .
‫Ma poi abbiamo già un costruttore qui, e userò questo costruttore per iscrivere i
‫metodi on game, iniziando con i metodi game over agli eventi on game start e on game over
‫eventi.
‫OK, quindi ora nel nostro gestore di eventi di gioco, aggiungiamo metodi statici pubblici per attivare gli eventi dal metodo
‫principale.
‫Quindi qui possiamo allora.
‫Call of, beh, fondamentalmente esegui questo evento, perché ora a questo punto, beh, dopo che tutti questi motori
‫di rendering, sistemi audio e lettori sono stati creati, una volta che questo evento verrà
‫attivato, eseguirà qualcosa.
‫Ma in realtà non abbiamo detto cosa dovrebbe succedere se ciò accade.
‫Quindi, se quell'evento verrà attivato, creiamo un metodo statico per l'attivazione all'avvio del gioco.
‫Quindi questo metodo qui, beh, prima di tutto, controlla se l'evento di avvio in-game non è vuoto, il che
‫significa che altri metodi lo hanno già sottoscritto, il che fondamentalmente sarà il caso una volta creato il motore di
‫rendering.
‫E questo codice qui viene eseguito, per esempio, oppure viene creato il sistema audio e viene eseguito questo codice oppure viene
‫creato il lettore e viene eseguito questo codice.
‫OK, allora questa affermazione qui sarà vera.
‫Quindi l'evento di gioco dell'evento START in corso non sarà vuoto, il che significa che non sarà nullo, e quindi questo
‫codice qui verrà eseguito.
‫Quindi quello che farà ora è dire che il gioco è iniziato e poi chiamerà l'inizio del gioco che
‫attiverà tutti i metodi sottoscritti a questo evento.
‫Quindi il che significa che una volta che chiamiamo questo metodo qui, quindi questo evento di gioco, per così
‫dire, una volta che lo chiamiamo questo metodo viene eseguito qui.
‫Questo metodo viene eseguito così come verrà eseguito questo metodo, e lo vedremo tra un
‫po'.
‫OK, questo è l'inizio del gioco scatenante.
‫Quindi è così che lo attiveremo.
‫E semplicemente chiamando questo metodo e vedi che lo stiamo rendendo statico, come abbiamo fatto con gli eventi di
‫gioco stessi, perché non abbiamo bisogno di creare un gestore di eventi di gioco per chiamare questi metodi.
‫Quindi è quello che vogliamo ottenere.
‫Ecco perché stiamo rendendo questo statico.
‫Quindi non è necessario creare un oggetto per chiamare questi metodi.
‫E poi creiamo un altro metodo statico per il loro game over.
‫E ti consiglierei di pubblicare un video e di provare a costruire te stesso ora molto velocemente.
‫OK, quindi spero che tu abbia postato che sia praticamente la stessa cosa che abbiamo fatto qui, ma ora lo farà con
‫il gioco delle Nazioni Unite qui.
‫Quindi ho questo metodo di gioco over trigger statico pubblico e void che attiverà l'evento e se unjam over non
‫è nullo.
‫Quindi, se ci sono metodi che sottoscrivono l'evento, allora questo non sarà falso e quindi sarà fondamentalmente vero, il che
‫significa che questo codice verrà eseguito e al game over verrà
‫eseguito, il che chiamerà quindi tutti i metodi di game over o tutti i metodi che hanno assegnato o
‫sottoscritto questo evento game over, il che significa questo metodo qui e questo metodo.
‫E infine, ovviamente, questo metodo.
‫Quindi ora, se vogliamo creare un nuovo motore, ora abbiamo il motore di rendering e il motore audio.
‫Diciamo che creiamo il terzo motore, quindi non abbiamo più bisogno di chiamare queste cose manualmente.
‫Ma l'abbiamo mandato lassù.
‫Quello che possiamo impostarlo direttamente nel motore in cui diciamo che vogliamo iscriverci a quell'evento e il
‫metodo verrà chiamato automaticamente una volta attivato quell'evento.
‫Va bene.
‫Quindi ora diamo un'occhiata al nostro codice nel metodo principale, perché qui stanno succedendo molte cose.
‫Quindi ora vedete che tutto questo codice non funziona più, ovviamente, perché tutti questi metodi di avvio
‫del gioco erano pubblici prima, ma ora non lo sono più.
‫Quindi ora lo sono.
‫Saranno quelli che sono privati, quindi sono chiusi.
‫Quindi ora andiamo avanti e assicuriamoci di attivare effettivamente questo evento di gioco.
‫Quindi qui abbiamo il gestore degli eventi di gioco e abbiamo avviato questo gioco trigger perché è quello che vogliamo fare
‫a questo punto.
‫Destra.
‫Quindi, una volta che tutti i giocatori e tutti i tuoi sistemi e tutto è pronto, possiamo andare avanti e farlo funzionare.
‫E ora possiamo fare la stessa cosa con il metodo game over qui sotto.
‫Quindi attiviamo l'evento game over qui sotto.
‫Quindi quello che accadrà ora è che ci consentirà di assicurarci di avere fondamentalmente un codice molto più semplice e
‫pulito.
‫Quindi si assicura che il nostro codice funzioni perfettamente.
‫Quindi ora diciamo di aggiungere un altro giocatore.
‫Non dobbiamo pensarci e chiamare correttamente tutti questi metodi, chiamato metodo di inizio gioco, chiamato metodo game
‫over e così via.
‫Possiamo semplicemente uscire e creare questo nuovo giocatore e chiamerà automaticamente i metodi di conseguenza.
‫Quindi vedete qui, il gioco ha avviato il sistema audio e ha iniziato a riprodurre l'audio, il
‫motore di rendering, il disegno delle immagini e quindi la generazione del giocatore Steve Call Douglas Silver e Dragon Doc.
‫Quindi ora premiamo il pulsante.
‫E potevi vedere che il gioco è finito, il sistema audio si è fermato, il motore di rendering si è fermato
‫e rimuoviamo tutti i giocatori.
‫Quindi questo è davvero il potere dei delegati multicast.
‫Super, super utile, molto potente.
‫Puoi vedere che il nostro terzo giocatore oggetto ha iniziato il gioco e il gioco è finito.
‫Il metodo viene chiamato automaticamente perché i nostri oggetti sono stati avvisati quando sono stati attivati sia gli eventi di inizio partita che
‫quelli di fine gioco.
‫Ora, quando si utilizzano i delegati, alcune cose possono andare storte.
‫Vediamo prima alcuni degli errori che possono costarci ore per essere riparati, diciamo per errore.
‫Invece di sottoscrivere un metodo al nostro evento usando il segno più uguale.
‫Passiamo, per esempio, alla classe del giocatore.
‫Invece di usare il segno più uguale avremmo usato per sbaglio solo il segno uguale.
‫Quindi il compilatore non dice che questo è sbagliato perché non è sbagliato.
‫Puoi anche sovrascrivere l'evento esistente con un solo metodo.
‫Quindi quello che stiamo facendo qui è dire che qualsiasi altra cosa sia stata sottoscritta a questo punto,
‫la sovrascriveremo.
‫Ed è quello che succederà sostanzialmente qui.
‫Quindi rimuoveremo tutti i metodi che facevano riferimento all'inizio del gioco e agli eventi di game over e impostando il
‫giocatore sull'ultimo oggetto giocatore, per la precisione, che è stato creato come unico abbonato a tutti questi
‫eventi.
‫Inoltre, dal momento che l'inizio del gioco finito è in realtà pubblico, possiamo chiamarli direttamente da qualsiasi luogo.
‫Quindi diciamo che vogliamo chiamare il gestore degli eventi di gioco all'avvio del gioco da qui, quindi possiamo farlo anche noi.
‫Quindi ora eseguiamo il codice.
‫E puoi vedere.
‫Il gioco ha iniziato a generare il gioco con il nostro Dragon Dog
‫su un Dragon Dong identico.
‫Quindi sì, prima l'evento è stato attivato dal nostro programma.
‫Sì.
‫E poi dal nostro ultimo giocatore, che era il nostro Dragon Dog.
‫Ha anche chiamato l'inizio in corso ancora una volta.
‫OK, quindi è fondamentalmente quello che è successo qui.
‫Quindi dobbiamo davvero stare attenti qui.
‫Questo è qualcosa che può essere molto difficile da risolvere.
‫Quindi ora possiamo contrassegnare i nostri eventi come privati perché abbiamo bisogno che siano pubblici per sottoscriverli nei nostri
‫costruttori di classi.
‫Quindi ora abbiamo usato il nome evento quando si parla di delegati perché i nostri delegati si comportavano
‫letteralmente come eventi.
‫Ma in realtà, c'è un tipo speciale di delegati chiamati eventi e che è fatto per prevenire questo tipo di
‫errori.
‫Va bene.
‫Quindi ora c'è una bellissima tastiera che ci aiuta a prevenire questo errore.
‫E questa è la parola chiave dell'evento perché fondamentalmente questo delegato che abbiamo creato nel nostro gestore di eventi
‫di gioco qui, questo evento di gioco statico pubblico è un evento.
‫Quindi avremmo potuto semplicemente usare questa parola chiave dell'evento qui.
‫E questo ci impedirebbe anche solo di commettere questo errore, perché ora vedi che non è
‫contento di ciò che abbiamo fatto qui, quindi possiamo scavalcare un delegato.
‫Ma quando si tratta di eventi, possiamo solo iscriverci.
‫E non possiamo semplicemente chiamare direttamente questo evento.
‫Verrà attivato direttamente dal gestore dell'evento di gioco, quindi non possiamo più chiamare l'evento direttamente, poiché su Game
‫Start ora è un evento e potremo chiamarlo solo dall'interno della classe in cui è
‫stato creato.
‫Inoltre, ci sta costringendo a trattarlo come un elenco, quindi non è consentito avere un evento sul lato sinistro del
‫segno di uguale.
‫Quindi una cosa del genere, come abbiamo visto, non è consentita.
‫Va bene.
‫E ora, se eseguiamo di nuovo l'app, vedrai che funziona perfettamente.
‫Fammi correre al codice.
‫E ha funzionato perfettamente.
‫Quindi questo è stato un esempio piuttosto condensato e piuttosto semplice perché abbiamo esaminato delegati, multicanale, delegati ed eventi
‫in un video.
‫Ma spero che questo video abbia chiarito quali vantaggi hai quando si tratta di lavorare con delegati ed
‫eventi.
‫E la cosa bella è che ora hai visto come creare i tuoi delegati così come
‫i tuoi eventi, perché vedremo un sacco di altri eventi in seguito quando si tratterà di utilizzare l'interfaccia utente.
‫Ad esempio, quando fai clic su qualcosa, viene attivato un evento e più elementi possono
‫iscriversi.
‫Più madri possono iscriversi a quell'evento che è stato attivato e quindi essere eseguito una volta, ad esempio, si
‫fa clic sul pulsante o si fa clic su un tasto qualsiasi della tastiera.
‫Va bene.
‫Quindi ora riassumiamo tutto molto velocemente.
‫Un evento è una forma ristretta di un delegato costretto a comportarsi come una lista, quindi possiamo solo aggiungere o rimuovere
‫metodi da esso in modo da poter sottoscrivere o annullare l'iscrizione da esso utilizzando il segno più uguale o meno uguale, ma
‫non il segno di uguale un delegato consente un'assegnazione diretta tramite il mio delegato è uguale al mio metodo.
‫In questo modo si sostituisce qualsiasi altro metodo sia stato aggiunto in precedenza.
‫Quindi stai attento qui.
‫Inoltre, gli eventi possono essere invocati solo dalla classe che li definisce dall'esterno della loro classe.
‫Puoi solo registrare e annullare la registrazione dei metodi a loro.
‫OK, spero che questo video vi sia piaciuto e che vi abbia dato una buona idea di eventi e delegati e spero
‫di vedervi nel prossimo video.