‫In Ordnung, in diesem Vortrag erfahren Sie mehr über Multicast-Delegierte und -Ereignisse.
‫Lassen Sie uns also zuerst das Problem untersuchen.
‫Stellen Sie sich vor, wir entwickeln ein Videospiel von Grund auf neu.
‫Unser Code ist eine Kombination aus Grafik- und Audiobibliotheken und der Logik für unseren Player.
‫Beginnen wir also mit der Codierung.
‫Betrachten Sie die folgenden einfachen Klassen.
‫Als erstes haben wir diese Rendering-Klasse, die zu Beginn des Spiels die Rendering-Engine aktivieren und mit
‫dem Zeichnen der Visuals beginnen möchten.
‫Es wird also gerendert und dann beginnt es mit dem Zeichnen von Visuals.
‫Und wenn das Spiel vorbei ist, wollen wir unsere Rendering-Engine stoppen.
‫Wir haben also diese Game-Over-Methode, die dann die Rendering-Engine stoppt.
‫Also verwende ich hier nur Konsolen-Anweisungen für die rechte Zeile.
‫Das wäre natürlich viel komplexerer Code und dieser würde dann tatsächlich etwas bewirken.
‫In unserem Fall.
‫Wir versuchen nur, das Konzept von Multicast-Delegierten sowie Ereignissen zu verstehen.
‫Deshalb werden wir es einfach über eine rote Zeilenanweisung auf der Konsole anzeigen.
‫Das ist also unsere Rendering-Klasse.
‫Schauen wir uns nun unsere Audiosystemklasse an.
‫Hier im Audiosystem haben wir also auch diese Dartspielmethode, die einfach das Audiosystem startet und
‫etwas Audio abspielt.
‫Und dann haben wir die Game-Over-Methode, die das Audiosystem im Grunde stoppt.
‫Und schließlich haben wir einen Spieler und der Spieler hat einen Spielernamen und wir haben diesen einfachen Konstruktor, bei dem
‫wir diesen Namen einfach basierend auf dem festlegen, was dem Objekt bei seiner Erstellung übergeben wurde.
‫Und Sie haben auch das Startspiel sowie die Game-Over-Methoden.
‫OK, dieser hier wird den Spieler mit einer Idee hervorbringen und dieser wird nur
‫den Spieler mit dieser bestimmten ID entfernen, die wir als Spielernamen zugewiesen haben.
‫OK, das sind unsere drei Klassen und ich werde es mit diesen ziemlich einfach halten.
‫Lassen Sie uns also weitermachen und zu unserer Hauptmethode übergehen.
‫Innerhalb unserer Hauptmethode werden wir nun Objekte dieser Systeme erstellen.
‫Also zuerst das Audiosystem und dann die Rendering Engine.
‫Also ganz einfach, nur einfache Objekte hier.
‫Und dann legen wir auch noch zwei Spieler mit der ID an.
‫Wir haben also diesen Spieler, einen, der Duco ist, und dann Spieler zwei, der Doggle Silva sein wird.
‫Wir müssen also unsere Rendering-Engine, unser Audiosystem starten und die Spieler sponsen, indem wir die start game-Methode
‫von jeder Klasse aus aufrufen.
‫Also machen wir das einfach.
‫Und ich werde es auf diese Weise tun, also werde ich nur sagen, dass das Audiosystem, das die Render-Engine zum Starten des Spiels
‫ist, nicht ein Spiel spielt und jeder Spieler das Spiel startet.
‫Und dann sagen wir einfach, dass das Spiel läuft.
‫Drücken Sie eine beliebige Taste, um das Spiel zu beenden.
‫Was wir jetzt also tun möchten, ist, das Spiel im Grunde zu beenden, sobald der Spieler den Knopf drücken muss.
‫Okay, dann wäre es natürlich viel komplexer.
‫Sagen wir, der Spieler drückt alle vier oder im Optionsmenü schließt er das Spiel, dann würde der nächste Platz
‫laufen.
‫Der nächste Code wäre also natürlich, das Audiosystem, diese Game-Over-Methoden-Rendering-Engine,
‫diese Game-Over-Methode sowie Spieler-Ein-Spieler-zu-Game-Over-Methoden aufzurufen.
‫Okay, also kümmern wir uns darum.
‫Fügen wir das auch hier hinzu.
‫Und übrigens, wir brauchen eine Read-Anweisung, da es sonst direkt heruntergefahren wird.
‫Lassen Sie mich hier also schnell eine Leseanweisung hinzufügen, damit wir tatsächlich manuell eine Taste drücken können, um dann alles
‫herunterzufahren und im Grunde zu spielen.
‫Also lass uns das ganz schnell laufen lassen und sehen, was passieren wird.
‫Wir sehen also, dass das gestartete Audiosystem bereits spielt, die Rendering-Engine gestartet ist.
‫Wir sehen jetzt die Visuals und dann werden die Spieler gespawnt.
‫Also Spieler eins und Spieler zu unserem Platz.
‫Jetzt läuft das Spiel und wir können damit herumspielen.
‫Und wenn wir es dann beenden wollen, drücken wir eine Taste.
‫Ich drücke also eine Taste und Sie sehen, wie die Rendering-Engine startet, das Audiosystem stoppt und wir
‫beide Player entfernen.
‫Es war also ein ziemlicher Aufwand, dies einzurichten.
‫Und ich stelle mir vor, dass wir das mit viel mehr Dingen tun müssen.
‫Und es könnte ein paar Dinge schief gehen.
‫Rechts.
‫Nehmen wir also an, wir fügen weitere Systeme hinzu, dann wird dies viel komplexer, sodass wir leicht vergessen können, die
‫Methode start game oder game over aufzurufen.
‫Oder noch schlimmer, wir könnten eine dieser Methoden zweimal aufrufen, was alle möglichen Probleme verursachen und
‫von uns verlangen kann, viel Schutzcode zu platzieren.
‫Wir müssten also wirklich sicherstellen, dass dieses Objekt lebt?
‫Hat es diese Methode genannt oder musste es die Polizei als viel zu kompliziert bezeichnet haben?
‫Und hier kommen Multicast-Delegierte zum Einsatz.
‫Ein Multicast-Delegierter ist ein Delegierter, der als Liste arbeitet.
‫Word kann einen Verweis auf mehr als eine Methode speichern, und das war's im Grunde.
‫Okay, das klingt ziemlich komplex, aber bauen wir es und dann wird es wahrscheinlich mehr Sinn machen.
‫Erstellen wir also eine statische Klasse namens Game Event Manager.
‫So.
‫In Ordnung, also lass uns weitermachen und eine neue erstellen.
‫Klasse hier.
‫Und ich werde dieses One Game Event Manager nennen.
‫Alles klar, dieser Spiel-Event-Manager hat jetzt einen Delegierten.
‫Also werde ich einen neuen Delegaten namens Game Event erstellen.
‫Es wird also nichts zurückgeben, aber es wird eng delegiert und öffentlich sein, damit wir
‫es außerhalb dieser Klasse verwenden können.
‫OK, wir haben also gesehen, wie Delegierte im Allgemeinen arbeiten.
‫Und wir werden diesen Delegaten jetzt verwenden, damit wir ihm im Grunde mehr als nur ein Ereignis hinzufügen können.
‫Lassen Sie uns also die beiden Variablen erstellen, die beim Spielstart und am Spielende aufgerufen werden, und sie werden vom Typ Spielereignis
‫sein.
‫Sie werden also nicht dem Typ unserer Delegierten entsprechen.
‫OK, dies wird also ein Spielereignisdelegierter sein und dies wird ein Spielereignisdelegierter sein.
‫Wir haben also diese beiden Delegatenvariablen, die wir jetzt verwenden können.
‫Also zurück zu unseren drei Klassen.
‫Kommen wir zum Startspiel und den Spielüber-Methoden zu den Spielstart- und Spielüber-Delegierten.
‫Außerdem müssen diese Methoden nicht öffentlich sein.
‫Gehen wir also zum Audiosystem über und machen wir diese beiden Methoden jetzt privat,
‫da wir sie nicht offenlegen müssen, da wir den Konstruktor des Audiosystems verwenden werden, um die Ereignisse hinzuzufügen oder zu
‫abonnieren.
‫Der beste Ort, um unsere Methoden zum Spiel, MENAGED-Delegaten, hinzuzufügen, ist hier also der Konstruktor selbst.
‫Okay, das machen wir hier.
‫Und wenn ein Objekt erstellt wird, wird seine Methode automatisch den Delegaten hinzugefügt, oder anders
‫ausgedrückt, sie abonnieren sie.
‫Was jetzt also passieren wird, ist, dass unser Startspiel und unsere
‫Game-Over-Methode zum Spielereignismanager des Spielstart-Delegierten hinzugefügt werden.
‫Und wir verwenden hier das Plus-Gleichheitszeichen, um zu sagen: OK, wir möchten diese Methode diesem Multicast-Delegaten hinzufügen.
‫Im Grunde abonnieren wir es und warten darauf, dass dieses Ereignis ausgelöst wird, denn
‫sobald dieses Ereignis ausgelöst wird, wird unsere Methode aufgerufen, OK.
‫Das Coole ist, dass wir jetzt dasselbe mit der Rendering-Engine-Klasse und der Player-Klasse machen können.
‫Wichtig ist hier also, dass ich das Plus-Gleichheitszeichen verwende und nicht nur das Gleichheitszeichen, also weise ich
‫es nicht zu.
‫Und wir werden später sehen, was eine Unterzeichnung bedeuten würde und was sie für uns tun wird.
‫Aber hier fügen wir nur ein weiteres hinzu.
‫Methode an unseren Eventsammler, sozusagen unseren Eventmanager.
‫OK, es sammelt also alle diese Ereignisse oder Methoden, die es dann ausführen soll.
‫Es ist also ein Multicast-Delegierter.
‫Machen wir nun dasselbe mit unserer Rendering-Engine.
‫Ich möchte, dass Sie es selbst tun.
‫Übergeben Sie also das Video ganz schnell und versuchen Sie, den gleichen Code zuzuweisen oder den gleichen Code aufzubauen, wie wir es
‫hier im Audiosystem getan haben.
‫OK, als erstes habe ich sichergestellt, dass meine Methoden privat bleiben, weil wir sie
‫nicht mehr veröffentlichen müssen, da dies nicht notwendig ist, wir werden sie außerhalb dieser Klasse nie aufrufen.
‫Deshalb ist es immer ratsam, sie privat zu machen.
‫Was wir jedoch nennen können, ist das Konstruktorrecht, damit wir ein Objekt unserer Rendering-Engine erstellen können, wie
‫es öffentlich ist.
‫Jetzt können wir also fortfahren und unsere START-Methode auch zum laufenden Start unseres Spiel-Event-Managers hinzufügen.
‫Und das Gleiche gilt für das Spielende.
‫Hier verwenden wir also auch plus gleich.
‫Wir sagen also, dass wir die On-Game-Start- und On-Game-Over-Events abonnieren.
‫Wir sagen also im Grunde, sobald das Spielstartereignis ausgelöst wird, rufen Sie bitte auch unsere Spielstartmethode auf.
‫Mit unserer meine ich, dass die Rendering-Engines die Spielmethode starten.
‫Es wird dann diese Methode aufrufen.
‫Und natürlich, wenn das Spiel vorbei ist, wird die Game-Over-Methode hier als diese bezeichnet.
‫So verwenden wir den Ansatz jetzt.
‫Kleine Herausforderung für dich.
‫Machen Sie bitte dasselbe in der Spielerklasse.
‫OK, also zunächst einmal hoffe ich, dass Sie bestehen und, nun ja, ich werde nicht auch sicherstellen, dass diese
‫beiden Methoden privat sind, weil niemand die Startspiel- und die Game-Over-Methode von außen aufrufen
‫soll .
‫Aber dann haben wir hier bereits einen Konstruktor, und ich werde diesen Konstruktor nur verwenden, um
‫die on game, start on game over Methoden zu den on game start events und on game over events zu
‫abonnieren.
‫OK, also fügen wir jetzt in unserem Spielereignismanager öffentlichen statischen Methoden hinzu, um die Ereignisse von der Hauptmethode
‫auszulösen.
‫Also hier können wir dann.
‫Aufruf von, na ja, im Grunde führt dieses Ereignis aus, denn jetzt an diesem Punkt, nun, nachdem
‫all diese Rendering-Engines, Audiosysteme und Player erstellt wurden, wird dieses Ereignis, sobald es ausgelöst
‫wird, etwas ausführen.
‫Aber wir haben nicht wirklich gesagt, was passieren soll, wenn das passiert.
‫Wenn dieses Ereignis also ausgelöst werden soll, erstellen wir eine statische Methode, die beim Spielstart ausgelöst wird.
‫Diese Methode hier überprüft also zunächst, ob das Startereignis im Spiel nicht leer ist, was bedeutet,
‫dass andere Methoden es bereits abonnieren, was im Grunde der Fall sein wird, sobald wir die Rendering-Engine erstellt
‫haben.
‫Und dieser Code hier wird zum Beispiel ausgeführt oder das Audiosystem wird erstellt und dieser Code wird ausgeführt oder der Player
‫wird erstellt und dieser Code wird ausgeführt.
‫OK, dann wird diese Aussage hier wahr sein.
‫Das laufende START-Event-Spielereignis ist also nicht leer, d. h. nicht null, und dann wird dieser Code
‫hier ausgeführt.
‫Was es jetzt tun wird, ist, dass es sagt, dass das Spiel gestartet wurde, und dann das Spiel starten aufrufen,
‫das alle Methoden auslöst, die dieses Ereignis abonniert haben.
‫Das heißt, wenn wir diese Methode hier aufrufen, sozusagen dieses Spielereignis, wird diese
‫Methode hier ausgeführt, sobald wir es nennen.
‫Diese Methode wird genauso ausgeführt, wie diese Methode ausgeführt wird, und das werden wir gleich noch
‫sehen.
‫OK, das ist also der Trigger-Spielstart.
‫So werden wir es auslösen.
‫Und indem Sie diese Methode einfach aufrufen, machen wir sie statisch, wie wir es bei den
‫Spielereignissen selbst getan haben, da wir keinen Spielereignis-Manager erstellen müssen, um diese Methoden aufzurufen.
‫Das wollen wir also erreichen.
‫Deshalb machen wir das statisch.
‫Sie müssen also kein Objekt erstellen, um diese Methoden aufzurufen.
‫Und dann erstellen wir eine weitere statische Methode für ihr eigenes Game Over.
‫Und ich würde empfehlen, dass Sie ein Video posten und versuchen, sich jetzt ganz schnell selbst aufzubauen.
‫Okay, ich hoffe, Sie haben gepostet, dass es im Grunde das Gleiche ist, wie wir es hier gemacht haben, aber jetzt wird es
‫mit dem UN-Spiel hier drüben passieren.
‫Also habe ich diese öffentliche statische, void-Trigger-Game-Over-Methode, die das Ereignis auslöst und wenn Unjam Over nicht
‫null ist.
‫Wenn es also Methoden gibt, die das Ereignis abonnieren, dann ist dies nicht falsch und dann ist es im
‫Grunde genommen wahr, was bedeutet, dass dieser Code ausgeführt
‫wird und bei Spielende ausgeführt wird, was dann alle Spielüber-Methoden aufruft oder alle Methoden, die dieses Game-Over-Ereignis zugewiesen
‫oder abonniert haben, was sowohl diese Methode hier als auch diese Methode bedeutet.
‫Und schließlich natürlich diese Methode.
‫Wenn wir jetzt also eine neue Engine erstellen möchten, haben wir jetzt die Rendering-Engine und die Audio-Engine.
‫Nehmen wir an, wir erstellen die dritte Engine, dann müssen wir dieses Zeug nicht mehr manuell aufrufen.
‫Aber wir haben es dorthin geschickt.
‫Was wir direkt in der Engine einrichten können, sagen wir, dass wir dieses Ereignis abonnieren möchten und die Methode
‫wird automatisch aufgerufen, sobald wir dieses Ereignis auslösen.
‫Gut.
‫Schauen wir uns nun unseren Code in der main-Methode an, denn hier ist viel los.
‫Jetzt sehen Sie, dass all dieser Code natürlich nicht mehr funktioniert, weil all diese Start-Spiel-Methoden
‫vorher öffentlich waren, aber jetzt sind sie es nicht mehr.
‫Jetzt sind sie es also.
‫Sie werden privat sein, also sind sie geschlossen.
‫Lassen Sie uns nun weitermachen und sicherstellen, dass wir dieses Spielereignis tatsächlich auslösen.
‫Hier haben wir also den Spiel-Event-Manager und wir hatten diesen Trigger-Spielstart, weil wir das an dieser Stelle
‫tun wollen.
‫Rechts.
‫Sobald also alle Spieler und alle Ihre Systeme und alles vorbereitet sind, können wir loslegen und es ausführen.
‫Und jetzt können wir das Gleiche mit der Game-Over-Methode hier unten machen.
‫Also lasst uns das Game Over Event hier unten auslösen.
‫Was jetzt also passieren wird, ist, dass wir sicherstellen können, dass wir grundsätzlich einen sehr viel einfacheren und saubereren Code
‫haben.
‫Es stellt also nur sicher, dass unser Code einwandfrei funktioniert.
‫Nehmen wir nun an, wir fügen ihm einen weiteren Spieler hinzu.
‫Wir müssen nicht darüber nachdenken und alle diese Methoden richtig nennen, die sogenannte Start-Spiel-Methode, die sogenannte
‫Game-Over-Methode und so weiter.
‫Wir können einfach diesen neuen Player erstellen und er wird die Methoden automatisch entsprechend aufrufen.
‫Sie sehen hier, das Spiel hat das Audiosystem gestartet und angefangen, Audio zu spielen, die
‫Engine zu rendern, Visuals zu zeichnen und dann die Spieler Steve Call Douglas Silver und Dragon Doc hervorzubringen.
‫Also lasst uns jetzt den Knopf drücken.
‫Und Sie konnten sehen, dass das Spiel vorbei ist, das Audiosystem gestoppt, die Rendering-Engine gestoppt und wir
‫alle Spieler entfernt haben.
‫Das ist also wirklich die Macht von Multicast-Delegierten.
‫Super, super nützlich, sehr mächtig.
‫Kann sehen, dass unser dritter Objektspieler das Startspiel und das Spiel beendet hat.
‫Die Methode wird automatisch aufgerufen, da unsere Objekte benachrichtigt wurden, wenn sowohl die Ereignisse bei Spielstart als auch bei
‫Spielende ausgelöst wurden.
‫Bei der Verwendung von Delegaten können einige Dinge schief gehen.
‫Sehen wir uns zuerst einige der Fehler an, deren Behebung Stunden kosten kann, sagen wir aus Versehen.
‫Anstatt eine Methode für unser Ereignis zu abonnieren, verwenden Sie das Plus-Gleichheitszeichen.
‫Kommen wir zum Beispiel zur Klasse des Spielers.
‫Anstatt das Plus-Gleichheitszeichen zu verwenden, hätten wir aus Versehen einfach das Gleichheitszeichen verwendet.
‫Der Compiler sagt also nicht, dass dies falsch ist, weil dies nicht falsch ist.
‫Sie können das vorhandene Ereignis auch mit nur einer Methode überschreiben.
‫Was wir hier also tun, ist, dass wir alles andere, was zu diesem Zeitpunkt abonniert wurde,
‫überschreiben werden.
‫Und genau das wird hier im Grunde passieren.
‫Wir werden also alle Methoden entfernen, die beim Spielstart und bei Spielüber-Ereignissen referenziert wurden, und den Spieler auf
‫das letzte Spielerobjekt setzen, um genau zu sein, das als einziges Abonnieren all dieser Ereignisse erstellt
‫wurde.
‫Da die ersten Schritte zum Game Over tatsächlich öffentlich sind, können wir sie von überall aus direkt aufrufen.
‫Nehmen wir also an, wir wollen von hier aus den Game Event Manager beim Spielstart anrufen, dann können wir das auch tun.
‫Lassen Sie uns nun den Code ausführen.
‫Und Sie können sehen.
‫Spawning-Spieler mit identischem Standbild und Silver Dragon Dong, das Spiel hat begonnen, mit unserem Dragon
‫Dog auf einem Dragon Dong zu spawnen.
‫Also ja, zuerst wurde das Event durch unser Programm ausgelöst.
‫Jawohl.
‫Und dann von unserem letzten Spieler, unserem Drachenhund.
‫Es nannte auch den laufenden Start noch einmal.
‫OK, das ist im Grunde hier passiert.
‫Wir müssen hier also wirklich vorsichtig sein.
‫Das ist etwas, das sehr schwer zu beheben sein kann.
‫Jetzt können wir unsere Ereignisse als privat markieren, da sie öffentlich sein müssen, um sie in unseren
‫Klassenkonstruktoren zu abonnieren.
‫Jetzt haben wir das Namensereignis verwendet, wenn wir über Delegierte sprachen, weil sich unsere Delegierten buchstäblich
‫wie Ereignisse benahmen.
‫Tatsächlich gibt es jedoch eine spezielle Art von Delegierten, die Events genannt werden, und die gemacht wird, um diese Art von Fehlern
‫zu vermeiden.
‫Gut.
‫Jetzt gibt es also eine schöne Tastatur, die uns hilft, diesen Fehler zu vermeiden.
‫Und das ist das Ereignis-Schlüsselwort, denn im Grunde ist dieser Delegierte, den wir hier in unserem
‫Spielereignis-Manager erstellt haben, dieses öffentliche statische Spielereignis ein Ereignis.
‫Wir hätten also einfach dieses Ereignis-Schlüsselwort hier verwenden können.
‫Und das würde uns daran hindern, diesen Fehler überhaupt zu machen, denn jetzt sehen Sie, dass es nicht
‫glücklich ist, was wir hier getan haben, damit wir einen Delegierten überschreiben können.
‫Aber wenn es um Events geht, können wir diese nur abonnieren.
‫Und wir können dieses Ereignis nicht einfach direkt aufrufen.
‫Es wird direkt vom Spielereignismanager ausgelöst, sodass wir das Ereignis nicht mehr direkt aufrufen können, da es bei Spielstart
‫jetzt ein Ereignis ist und wir es nur innerhalb der Klasse aufrufen dürfen, in der es
‫erstellt wurde.
‫Außerdem zwingt es uns, es wie eine Liste zu behandeln, sodass ein Ereignis auf der linken Seite des Gleichheitszeichens
‫nicht zulässig ist.
‫So etwas ist, wie wir gesehen haben, nicht erlaubt.
‫Gut.
‫Und wenn wir die App jetzt erneut ausführen, werden Sie feststellen, dass sie einwandfrei funktioniert.
‫Lassen Sie mich zum Code laufen.
‫Und es hat perfekt funktioniert.
‫Dies war also ein ziemlich komprimiertes Beispiel und ein ziemlich einfaches, da wir Delegierte, Multichannels, Delegierte und Veranstaltungen in einem
‫Video untersucht haben.
‫Aber ich hoffe, dass dieses Video deutlich gemacht hat, welche Vorteile Sie in der Arbeit mit Delegierten und Veranstaltungen
‫haben.
‫Und das Coole ist, dass Sie jetzt gesehen haben, wie Sie Ihre eigenen Delegierten sowie Ihre eigenen
‫Events erstellen, denn wir werden später noch eine Reihe weiterer Events sehen, wenn es um die Verwendung der Benutzeroberfläche geht.
‫Wenn Sie beispielsweise auf etwas klicken, wird ein Ereignis ausgelöst und mehrere Dinge können abonniert
‫werden.
‫Das ausgelöste Ereignis kann von mehreren Müttern abonniert und dann ausgeführt werden, wenn beispielsweise der
‫Button angeklickt oder eine beliebige Taste auf der Tastatur angeklickt wird.
‫Gut.
‫Also fassen wir es jetzt ganz schnell zusammen.
‫Ein Ereignis ist eine eingeschränkte Form eines Delegaten, der gezwungen ist, sich wie eine Liste zu verhalten, sodass wir
‫ihm nur Methoden hinzufügen oder daraus entfernen können, damit wir ihn mit dem Plus-Gleichheits- oder Minus-Gleichheitszeichen, aber nicht mit dem
‫Gleichheitszeichen eines Delegaten, abonnieren oder abbestellen können ermöglicht eine direkte Zuweisung über meinen Delegaten entspricht meiner Methode.
‫Dadurch werden alle anderen Methoden ersetzt, die zuvor hinzugefügt wurden.
‫Seien Sie also hier vorsichtig.
‫Außerdem können Ereignisse nur von der Klasse aufgerufen werden, die sie außerhalb ihrer Klasse definiert.
‫Sie können nur Methoden für sie registrieren und die Registrierung aufheben.
‫Okay, ich hoffe, Ihnen hat dieses Video gefallen und Ihnen eine gute Vorstellung von Veranstaltungen und Delegierten vermittelt und ich hoffe, Sie
‫im nächsten Video zu sehen.