‫Très bien, donc dans cette conférence, vous en apprendrez davantage sur les délégués et les événements multidiffusion.
‫Examinons donc d'abord le problème.
‫Imaginez que nous développons un jeu vidéo à partir de zéro.
‫Notre code est une combinaison de bibliothèques graphiques et audio et de la logique de notre lecteur.
‫Commençons donc à le coder.
‫Considérez les classes simples suivantes.
‫Donc tout d'abord, nous avons cette classe de rendu, qui au début du jeu, nous voulons activer le moteur de
‫rendu et commencer à dessiner les visuels.
‫Donc ça va être rendu et ensuite ça va commencer à dessiner des visuels.
‫Et aussi, lorsque le jeu est terminé, nous voulons arrêter notre moteur de rendu.
‫Nous avons donc cette méthode game over qui arrêtera alors le moteur de rendu.
‫Donc, ici, j'utilise simplement les instructions de ligne droite de la console.
‫Ce serait, bien sûr, un code beaucoup plus complexe et cela ferait alors quelque chose.
‫Dans notre cas.
‫Nous essayons simplement de comprendre le concept de délégués multicast ainsi que d'événements.
‫C'est pourquoi nous allons simplement l'afficher via une déclaration de ligne rouge sur la console.
‫C'est donc notre classe de rendu.
‫Regardons maintenant notre classe de système audio.
‫Donc, ici, dans le système audio, nous avons également cette méthode de jeu de fléchettes, qui va simplement démarrer le système audio
‫et lire de l'audio.
‫Et puis nous avons la méthode game over, qui arrêtera essentiellement le système audio.
‫Et puis enfin, nous avons un joueur et le joueur a un nom de joueur et nous avons ce constructeur simple où nous
‫définissons simplement ce nom en fonction de ce qui a été passé à l'objet lors de sa création.
‫Et vous avez également le jeu de démarrage ainsi que les méthodes de jeu fini.
‫OK, donc celui-ci va donner une idée au joueur et celui-ci va simplement supprimer le
‫joueur avec cet ID particulier que nous avons attribué comme nom de joueur.
‫OK, ce sont donc nos trois classes et je vais rester assez simple avec celles-ci.
‫Alors allons-y et passons à notre méthode principale.
‫Donc, à l'intérieur de notre méthode principale, nous allons maintenant créer des objets de ces systèmes.
‫Donc d'abord du système audio et ensuite du moteur de rendu.
‫Donc très simple, juste des objets simples ici.
‫Et puis nous créons également deux joueurs avec l'ID.
‫Nous avons donc ce joueur, un qui est Duco, puis le deuxième joueur, qui va être doggle Silva.
‫Nous devons donc démarrer notre moteur de rendu, notre système audio et parrainer les joueurs en appelant la méthode
‫start game depuis chacune des classes.
‫Alors faisons juste ça.
‫Et je vais le faire de cette façon, donc je vais juste dire que le système audio qui démarre le moteur de rendu du jeu
‫ne joue pas un jeu et que le joueur démarre le jeu chacun.
‫Et puis nous disons simplement que le jeu est en cours d'exécution.
‫Appuyez sur n'importe quelle touche pour terminer le jeu.
‫Donc, ce que nous voulons faire maintenant, c'est que nous voulons essentiellement terminer le jeu une fois que le joueur doit appuyer sur le bouton.
‫OK, donc ce serait bien sûr beaucoup plus complexe.
‫Disons que le joueur appuie sur les quatre ou dans le menu des options, il ferme le jeu, puis le prochain court
‫se déroulera.
‫Donc, le prochain code serait, bien sûr, d'appeler le système audio, ce moteur de rendu de méthode de jeu par-dessus, cette méthode
‫de jeu par-dessus, ainsi que les méthodes de jeu par joueur à un joueur.
‫OK, alors prenons soin de ça.
‫Ajoutons cela ici aussi.
‫Et au fait, nous aurons besoin d'une instruction read car sinon elle l'arrêtera directement.
‫Alors permettez-moi d'ajouter rapidement une instruction read ici afin que nous puissions réellement appuyer manuellement sur une touche pour ensuite tout
‫arrêter et fondamentalement le jeu terminé.
‫Alors allons-y très vite et voyons ce qui va se passer.
‫Nous voyons donc que le système audio démarré est déjà en cours de lecture, le moteur de rendu a démarré.
‫Nous voyons maintenant les visuels, puis les joueurs sont générés.
‫Alors joueur un et joueur à notre place.
‫Maintenant, le jeu est en cours d'exécution et nous pouvons jouer avec.
‫Et puis une fois qu'on veut le finir, on appuie sur une touche.
‫Je vais donc appuyer sur une touche et vous voyez le moteur de rendu démarrer, le système audio s'est arrêté et
‫nous enlevons les deux lecteurs.
‫C'était donc tout un effort pour mettre cela en place.
‫Et j'imagine que nous devons le faire avec beaucoup plus de choses.
‫Et il pourrait y avoir un certain nombre de choses qui pourraient mal se passer.
‫Droit.
‫Alors disons que nous ajoutons plus de systèmes, puis cela devient beaucoup plus complexe et nous pouvons facilement oublier d'appeler
‫la méthode start game ou game over.
‫Ou pire encore, nous pourrions appeler deux fois l'une de ces méthodes, ce qui pourrait causer toutes sortes de problèmes
‫et nous obliger à placer beaucoup de code de protection.
‫Il faudrait donc vraiment s'assurer que cet objet est vivant ?
‫A-t-il appelé cette méthode ou a-t-il dû appeler les méthodes policières de façon trop compliquée ?
‫Et c'est là que les délégués multicast sont utiles.
‫Un délégué multicast est un délégué qui fonctionne comme une liste.
‫Word peut stocker une référence à plusieurs méthodes, et c'est tout.
‫D'accord, cela semble assez complexe, mais construisons-le et cela aura probablement plus de sens.
‫Créons donc une classe statique appelée gestionnaire d'événements de jeu.
‫Donc.
‫Très bien, alors allons-y et créons-en un nouveau.
‫Classez ici.
‫Et je vais appeler ce gestionnaire d'événements de jeu.
‫Très bien, donc ce gestionnaire d'événements de jeu aura maintenant un délégué.
‫Je vais donc créer un nouveau délégué appelé Game Event.
‫Donc ça ne va rien retourner, mais ça va être un délégué serré et ça va être public afin que
‫nous puissions l'utiliser en dehors de cette classe.
‫OK, donc nous avons vu comment les délégués travaillent en général.
‫Et nous allons maintenant utiliser ce délégué pour nous permettre d'y ajouter plus d'un événement.
‫Créons donc les deux variables appelées au début du jeu et à la fin du jeu, et elles seront hors type d'événement de
‫jeu.
‫Donc, ils seront hors du type de nos délégués.
‫OK, donc ce sera un délégué d'événement de jeu et ce sera un délégué d'événement de jeu.
‫Nous avons donc ces deux variables déléguées que nous pouvons maintenant utiliser.
‫Revenons donc à nos trois classes.
‫Passons au jeu de départ et aux méthodes de jeu sur les délégués au début du jeu et au jeu sur.
‫De plus, il n'est pas nécessaire que ces méthodes soient publiques.
‫Passons donc au système audio et rendons maintenant ces deux méthodes privées car nous
‫n'avons pas besoin de les exposer car nous allons utiliser le constructeur du système audio pour ajouter ou souscrire aux
‫événements.
‫Donc ici, le meilleur endroit pour ajouter nos méthodes au jeu, les délégués MENAGED, est à l'intérieur du constructeur
‫lui-même.
‫OK, c'est ce que nous faisons ici.
‫Et lorsqu'un objet est créé, sa méthode sera automatiquement ajoutée aux délégués ou en d'autres
‫termes, ils y souscriront.
‫Donc, ce qui va se passer maintenant, c'est que notre jeu de démarrage et notre méthode de jeu terminé vont
‫être ajoutés au gestionnaire d'événements de jeu sur le délégué de démarrage du jeu.
‫Et nous utilisons ici le signe plus égal pour dire, OK, nous voulons ajouter cette méthode à ce délégué de
‫multidiffusion.
‫Donc, fondamentalement, nous y souscrivons et nous attendons que cet événement soit déclenché car une
‫fois que cet événement sera déclenché, notre méthode sera appelée, OK.
‫Donc, ce qui est cool, c'est que nous pouvons maintenant faire la même chose avec la classe du moteur de rendu et la classe du joueur.
‫Donc, ce qui est important ici, c'est que j'utilise le signe plus égal et pas seulement le signe égal, donc
‫je ne l'attribue pas.
‫Et nous verrons plus tard ce que signifierait une signature et ce que cela fera pour nous.
‫Mais ici, nous en ajoutons simplement un autre.
‫Méthode à notre collectionneur d'événements, pour ainsi dire, notre gestionnaire d'événements.
‫OK, il collecte donc tous ces événements ou méthodes qu'il doit ensuite exécuter.
‫C'est donc un délégué multicast.
‫Faisons maintenant la même chose avec notre moteur de rendu.
‫J'aimerais que vous le fassiez vous-même.
‫Alors passez la vidéo très rapidement et essayez d'attribuer le même code ou de créer le même code que nous avons fait
‫dans le système audio ici.
‫OK, donc tout d'abord, je me suis assuré que mes méthodes seront privées car nous n'avons
‫plus besoin de les exposer car ce n'est pas nécessaire, nous ne les appellerons jamais en dehors de cette classe.
‫C'est pourquoi c'est toujours une bonne pratique de les rendre privés.
‫Ce que nous pouvons appeler, cependant, est le droit du constructeur, nous pouvons donc créer un objet de notre moteur de rendu
‫car il est public.
‫Nous pouvons donc maintenant ajouter notre méthode START au démarrage en cours de notre gestionnaire d'événements de jeu.
‫Et il en va de même pour le jeu terminé.
‫Donc, ici, nous utilisons également plus est égal à.
‫Nous disons donc que nous souscrivons aux événements de début de partie et de fin de partie.
‫Donc, en gros, nous disons qu'une fois que l'événement de démarrage du jeu sera déclenché, appelez également notre méthode de démarrage du jeu, s'il vous
‫plaît.
‫Par notre j'entends la méthode de démarrage des moteurs de rendu.
‫Il appellera donc cette méthode.
‫Et bien sûr, si le jeu est terminé, alors la méthode de jeu sera appelée celle-ci ici.
‫C'est ainsi que nous utilisons l'approche maintenant.
‫Petit défi pour vous.
‫Faites la même chose dans la classe de joueur, s'il vous plaît.
‫OK, alors tout d'abord, j'espère que vous réussirez et, bon, je ne vais pas aussi m'assurer que ces deux méthodes vont être privées
‫car personne n'est censé appeler la méthode de démarrage et la méthode de jeu fini de
‫l'extérieur. .
‫Mais nous avons déjà un constructeur ici, et je vais simplement utiliser ce constructeur pour
‫souscrire au jeu on, en commençant par les méthodes de game over jusqu'aux événements on game start et on game
‫over.
‫OK, alors maintenant dans notre gestionnaire d'événements de jeu, ajoutons aux méthodes statiques publiques pour déclencher les événements à partir de la méthode
‫principale.
‫Donc ici, nous pouvons alors.
‫Appel de, eh bien, exécutez essentiellement cet événement, car maintenant, à ce stade, eh bien, après la création de tous
‫ces moteurs de rendu, systèmes audio et lecteurs, une fois que cet événement sera déclenché, il
‫exécutera quelque chose.
‫Mais nous n'avons pas vraiment dit ce qui devrait arriver si cela se produit.
‫Donc, si cet événement doit être déclenché, créons une méthode statique à déclencher au démarrage du jeu.
‫Donc cette méthode ici, eh bien, tout d'abord, vérifiez si l'événement de démarrage du jeu n'est pas vide, ce qui signifie
‫que d'autres méthodes y sont déjà abonnés, ce qui sera essentiellement le cas une fois que nous aurons créé le moteur de
‫rendu.
‫Et ce code ici est exécuté, par exemple, ou le système audio est créé et ce code est exécuté ou le
‫lecteur est créé et ce code est exécuté.
‫OK, alors cette déclaration ici sera vraie.
‫Ainsi, l'événement de jeu de l'événement START en cours ne sera pas vide, ce qui signifie qu'il ne sera pas nul, puis ce
‫code ici sera exécuté.
‫Donc, ce qu'il va faire maintenant, c'est dire que le jeu a commencé, puis il appellera le démarrage du jeu
‫qui déclenchera toutes les méthodes souscrites à cet événement.
‫Cela signifie donc qu'une fois que nous appelons cette méthode ici, cet événement de jeu, pour ainsi dire,
‫une fois que nous l'appelons, cette méthode est exécutée ici.
‫Cette méthode est exécutée ainsi que cette méthode sera exécutée, et nous allons le voir dans un instant
‫également.
‫OK, c'est donc le début du jeu déclencheur.
‫C'est ainsi que nous allons le déclencher.
‫Et en appelant simplement cette méthode, vous voyez que nous la rendons statique, comme nous l'avons fait avec les événements
‫de jeu eux-mêmes, car nous n'avons pas besoin de créer un gestionnaire d'événements de jeu pour appeler ces méthodes.
‫C'est donc ce que nous voulons atteindre.
‫C'est pourquoi nous rendons cela statique.
‫Vous n'avez donc pas besoin de créer un objet pour appeler ces méthodes.
‫Et puis créons une autre méthode statique pour leur propre game over.
‫Et je vous recommanderais de publier une vidéo et d'essayer de vous construire maintenant très rapidement.
‫OK, alors j'espère que vous avez posté c'est fondamentalement la même chose que nous avons fait ici, mais maintenant ça va le faire
‫avec le jeu de l'ONU ici.
‫J'ai donc cette méthode de jeu de déclenchement public statique et void qui déclenchera l'événement et si unjam over n'est
‫pas nul.
‫Donc, s'il y a des méthodes qui s'abonnent à l'événement, alors ce ne sera pas faux et alors ce sera fondamentalement vrai,
‫ce qui signifie que ce code sera exécuté et sur game over
‫sera exécuté, ce qui appellera alors toutes les méthodes de game over ou toutes les méthodes qui ont attribué ou souscrit
‫à cet événement game over, ce qui signifie cette méthode ici ainsi que cette méthode.
‫Et enfin, bien sûr, cette méthode.
‫Alors maintenant, si nous voulons créer un nouveau moteur, nous avons maintenant le moteur de rendu et le moteur audio.
‫Disons que nous créons le troisième moteur, alors nous n'avons plus besoin d'appeler ce truc manuellement.
‫Mais nous l'avons envoyé là-haut.
‫Ce que nous pouvons configurer directement dans le moteur où nous disons que nous voulons nous abonner à cet événement et la méthode sera
‫automatiquement appelée une fois que nous aurons déclenché cet événement.
‫D'accord.
‫Voyons maintenant notre code dans la méthode main, car il se passe beaucoup de choses ici.
‫Alors maintenant, vous voyez que tout ce code ne fonctionne plus, bien sûr, parce que toutes ces méthodes de jeu
‫de démarrage étaient publiques auparavant, mais maintenant elles ne le sont plus.
‫Alors maintenant, ils le sont.
‫Ça va être ce qu'ils sont privés, donc ils sont fermés.
‫Alors maintenant, allons de l'avant et assurons-nous que nous déclenchons réellement cet événement de jeu.
‫Nous avons donc ici le gestionnaire d'événements de jeu et nous avons eu ce jeu de déclenchement parce que c'est ce que nous voulons faire
‫à ce stade.
‫Droit.
‫Donc, une fois que tous les joueurs et tous vos systèmes et tout est préparé, nous pouvons continuer et l'exécuter.
‫Et maintenant, nous pouvons faire la même chose avec la méthode game over ici.
‫Déclenchons donc l'événement game over ici.
‫Ce qui va se passer maintenant, c'est que cela nous permettra de nous assurer que nous avons fondamentalement un code beaucoup plus simple et
‫plus propre.
‫Ainsi, cela garantit simplement que notre code fonctionnera parfaitement.
‫Alors maintenant, disons que nous y ajoutons un autre joueur.
‫Nous n'avons pas besoin d'y penser et d'appeler toutes ces méthodes correctement, appelées méthode de démarrage du jeu, appelée méthode de
‫jeu fini et ainsi de suite.
‫Nous pouvons simplement sortir et créer ce nouveau lecteur et il appellera automatiquement les méthodes en conséquence.
‫Donc, vous voyez ici, le jeu a démarré le système audio et a commencé à jouer
‫de l'audio, un moteur de rendu, des visuels de dessin, puis le joueur Steve Call Douglas Silver et Dragon Doc.
‫Alors maintenant, appuyons sur le bouton.
‫Et vous pouviez voir que le jeu était terminé, que le système audio s'était arrêté, que le moteur de rendu s'était arrêté et
‫que nous supprimions tous les joueurs.
‫C'est donc vraiment le pouvoir des délégués multicast.
‫Super, super utile, très puissant.
‫Peut voir que notre troisième joueur objet a le jeu de départ et le jeu est terminé.
‫La méthode est appelée automatiquement car nos objets ont été notifiés lorsque les événements de début de partie et de fin de
‫partie ont été déclenchés.
‫Désormais, lorsque vous utilisez des délégués, certaines choses peuvent mal se passer.
‫Voyons d'abord quelques-unes des erreurs qui peuvent nous coûter des heures à corriger, disons par erreur.
‫Au lieu de vous abonner à une méthode pour notre événement en utilisant le signe plus égal.
‫Passons par exemple à la classe du joueur.
‫Au lieu d'utiliser le signe égal plus, nous aurions par accident simplement utilisé le signe égal.
‫Donc le compilateur ne dit pas que c'est faux parce que ce n'est pas faux.
‫Vous pouvez également remplacer l'événement existant avec une seule méthode.
‫Donc, ce que nous faisons ici, c'est que nous disons que tout ce qui a été souscrit à ce stade, nous
‫allons le remplacer.
‫Et c'est ce qui se passera essentiellement ici.
‫Nous allons donc supprimer toutes les méthodes référencées dans les événements de début de partie et de fin de partie et définir le
‫joueur sur le dernier objet joueur, pour être précis, qui a été créé comme le seul abonnement à tous
‫ces événements.
‫De plus, comme la mise en route de la fin du jeu est en fait publique, nous pouvons les appeler directement de n'importe où.
‫Disons que nous voulons appeler le gestionnaire d'événements de jeu au démarrage du jeu à partir d'ici, alors nous pouvons le faire également.
‫Alors maintenant, exécutons le code.
‫Et vous pouvez voir.
‫Joueur apparaissant avec un alambic identique et Silver Dragon Dong, le jeu a commencé à jouer avec
‫notre Dragon Dog sur un Dragon Dong.
‫Alors oui, d'abord l'événement a été déclenché par notre programme.
‫Oui.
‫Et puis de notre dernier joueur, qui était notre Dragon Dog.
‫Il a également appelé à nouveau le démarrage en cours.
‫OK, c'est donc essentiellement ce qui s'est passé ici.
‫Nous devons donc vraiment faire attention ici.
‫C'est quelque chose qui peut être très difficile à corriger.
‫Nous pouvons donc maintenant marquer nos événements comme privés car nous avons besoin qu'ils soient publics pour y souscrire dans nos
‫constructeurs de classe.
‫Alors maintenant, nous utilisons le nom d'événement lorsque nous parlons de délégués parce que nos délégués se comportaient littéralement
‫comme des événements.
‫Mais en fait, il existe un type spécial de délégués appelés événements et qui est fait pour éviter ce genre
‫d'erreurs.
‫D'accord.
‫Alors maintenant, il y a un beau clavier qui nous aide à éviter cette erreur.
‫Et c'est le mot-clé de l'événement car fondamentalement ce délégué que nous avons créé dans notre gestionnaire d'événements de
‫jeu ici, cet événement de jeu statique public est un événement.
‫Nous aurions donc pu simplement utiliser ce mot-clé d'événement ici.
‫Et cela nous empêcherait même de faire cette erreur, parce que maintenant vous voyez qu'il n'est pas content de
‫ce que nous avons fait ici afin que nous puissions passer outre un délégué.
‫Mais lorsqu'il s'agit d'événements, nous ne pouvons que souscrire à eux.
‫Et nous ne pouvons pas simplement appeler cet événement directement.
‫Il sera déclenché directement depuis le gestionnaire d'événements du jeu afin que nous ne puissions plus appeler l'événement directement, car sur Game Start
‫est désormais un événement et nous ne serons autorisés à l'appeler qu'à partir de la classe où il a
‫été créé.
‫Et aussi, cela nous oblige à le traiter comme une liste, donc avoir un événement sur le côté gauche du signe égal
‫n'est pas autorisé.
‫Donc quelque chose comme ça, comme nous l'avons vu, ce n'est pas autorisé.
‫D'accord.
‫Et maintenant, si nous exécutons à nouveau l'application, vous verrez qu'elle fonctionne parfaitement.
‫Laisse-moi courir pour coder.
‫Et cela a parfaitement bien fonctionné.
‫C'était donc un exemple assez condensé et plutôt simple car nous avons examiné les délégués, les multicanaux, les délégués et les événements
‫dans une seule vidéo.
‫Mais j'espère que cette vidéo a clairement montré quels avantages vous avez quand il s'agit de travailler avec des délégués et des
‫événements.
‫Et ce qui est bien, c'est que vous avez maintenant vu comment créer vos propres délégués ainsi que
‫vos propres événements, car nous allons voir un tas d'autres événements plus tard en ce qui concerne l'utilisation de l'interface utilisateur.
‫Par exemple, lorsque vous cliquez sur quelque chose, un événement est déclenché et plusieurs choses
‫peuvent s'abonner.
‫Plusieurs mères peuvent s'abonner à cet événement qui a été déclenché puis être exécuté une fois, par
‫exemple, le bouton est cliqué ou n'importe quelle touche du clavier est cliqué.
‫D'accord.
‫Alors maintenant, résumons-le très rapidement.
‫Un événement est une forme restreinte d'un délégué obligé de se comporter comme une liste de sorte que nous ne pouvons qu'ajouter
‫ou supprimer des méthodes de celle-ci afin que nous puissions nous abonner ou nous en désabonner en utilisant le signe plus égal ou
‫moins égal, mais pas le signe égal un délégué permet une affectation directe via mon délégué équivaut à ma méthode.
‫Cela remplace toutes les autres méthodes qui y ont été ajoutées auparavant.
‫Soyez donc prudent ici.
‫De plus, les événements ne peuvent être invoqués que par la classe qui les définit depuis l'extérieur de leur classe.
‫Vous pouvez uniquement enregistrer et désenregistrer des méthodes pour eux.
‫OK, alors j'espère que vous avez apprécié cette vidéo et cela vous a donné une bonne idée des événements et des délégués et j'espère
‫vous voir dans la prochaine vidéo.