Unsere Datenschutzrichtlinie wird in Kürze aktualisiert. Bitte sehen Sie sich die Vorschau an.

Visual C# 2011 Grundkurs

Events

Testen Sie unsere 2016 Kurse

10 Tage kostenlos!

Jetzt testen Alle Abonnements anzeigen
Delegates ausserhalb einer Klasse sichtbar zu machen, ist keine gute Idee. Ebenso, wie Felder durch Properties gekapselt werden, kann man Delegaten mit Events kapseln.
07:46

Transkript

Delegaten ermöglichen einem in C# Code auszuführen, der nicht unbedingt in der eigenen Klasse definiert ist, sondern erst nach Entwicklung der Klasse geschrieben werden kann. Manchmal kommt es aber zu Komplikationen, weil man diesen Zugriff auf den Delegaten, der nach außen hin angeboten wird, gar nicht kontrollieren kann. Das kann man mit Events, und wie das funktioniert, schauen wir uns in diesem Video einmal an.  Ich habe dazu ein Beispiel vorbereitet. Wir haben zunächst eine Klasse "Button". In dieser Klasse "Button" gibt es eine klick()-Methode, das ist quasi eine Art Button in der Konsole, da wir ja noch keine graphischen Oberflächen haben. Und diesen Button kann ich mit Aufruf der click()-Methode anklicken. Und wenn ich diesen Button anklicke, dann führt der einen Delegaten aus, den Delegaten "klickt" hier oben. Der ist "public" definiert, also nach außen hin sichtbar. Delegat ist vom Typ clickHandler, und der clickHandler-Delegat ist so definiert, dass er auf eine Methode zeigen kann, die keinen Rückgabetyp hat und keine Parameter entgegennehmen kann. Hier in unserer main-Methode haben wir von dem Button eine Instanz erstellt, haben an diesen Delegaten ein Objekt zugewiesen, was auf myClick-method zeigt, das ist diese Methode hier unten, die wir gerne ausführen möchten. Und danach klicken wir diesen Button, so. Ich führe das ganz mal aus, um es kurz zu zeigen. Es wird also dann, wenn ich den Button klicke, der Delegat aufgerufen, und dann mein eigener Text ausgegeben. Jetzt sind Delegaten natürlich ein Hilfsmittel, was man in der Praxis sehr, sehr gut benutzen kann Und sehr schöne und gut designte Anwendungen machen kann, eben dadurch, dass ich lose gekoppelte Anwendungen entwickeln kann. Nicht schön ist allerdings, dass ich auf diesen Delegaten von draußen zugreifen kann. Ich könnte z.B. einfach sagen, dieser Delegat, der dort definiert ist, den führe ich jetzt einfach mal aus.  Also ich mache das nicht über die click()-Methode, sondern ich rufe ihn direkt auf. Wenn ich das dann ausführe, dann wird zweimal diese Methode aufgerufen. Und das möchte ich ja unter Umständen gar nicht, dass jemand von außen derartigen Zugriff auf diesen Delegaten hat und den aufrufen kann. Auf der anderen Seite könnte man die Referenz also auf das Objekt von dem Delegaten, auf den diese click-Referenz zeigt, könnte ich einfach löschen. Ich könnte einfach hingehen und sagen: "clicked = null". Dann wäre diese Referenz von dem Delegaten einfach weg. Und sowas möchte man einfach nicht, dass das jemand von draußen machen kann, weil das könnten wir jetzt hier machen, das könnte auch ein fremder Entwickler machen und dann irgendwie die Klasse derart manipulieren, dass sie plötzlich nicht mehr funktioniert. Wie gesagt, das möchte man nicht und das Ganze kann man verhindern. Wir haben ein ähnliches Problem bei Feldern. Auch bei Feldern möchten wir nicht, dass Felder nach außen hin public gemacht werden. Wir möchten Kontrolle darauf haben, wenn Werte gesetzt werden und Werte ausgelesen werden. Dafür gibt es "Properties". Diese Properties haben einen getter und einen setter und im setter kann ich prüfen, wenn diese Variable gesetzt wird, ob sie bestimmte Bedingungen einhält z.B. Und im getter kann ich dann den Wert dieser Variable zurückgeben. So ein ähnliches Konzept gibt es auch für Delegaten. Bei Delegaten sind es allerdings nicht Properties, also Eigenschaften, sondern es sind Events. Also was Properties für Felder sind, sind Events für Delegates. Wir definieren uns hier erstmal unser Event, wir sagen zunächst "public Event", dann müssen wir sagen, welche Art von Delegaten wir kapseln wollen. Wir möchten einen clickHandler kapseln. Und dann nennen wir unser Event einmal clickEvent. Auch das ist so eine Konvention, so eine Namenskonvention, dass man an Events am Ende das Wort "Event" dranhängt. Jetzt habe ich hier unten so einen Anweisungsblock. Und während ich bei einem Property zum Kapseln von Feldern einen get- und set-Bereich hatte, habe ich hier einen add- und einen remove-Bereich. Diese Bereiche habe ich deshalb, weil an Delegaten kann ich nicht nur - wie wir es hier in der Program.cs gemacht haben - ein Objekt von einem Delegaten einfach zuweisen, sondern ich könnte auch so etwas machen, wie den "+="-Operator. Das heißt, ich hänge an diesen Delegaten eine Methode dran. Und dann könnte ich auch hingehen und könnte mehrere Methoden dranhängen. Und wenn man dann diesen Delegaten aufrufen würde, würden nach und nach diese Methoden ausgeführt. Genauso gut könnte ich aber hingehen, und könnte diese Methoden mit "-=" auch wieder entfernen, wenn ich sie mal hinzugefügt habe. Deswegen gibt es "add" und "remove". Hierbei wird "add" aufgerufen und wenn ich den Delegaten wieder entferne, wird "remove" aufgerufen. Und in diesem add-Bereich gehen wir jetzt einfach hin, wie wir das schon bei den Properties haben, kann ich jetzt hier einfach auf den Wert, der von außen angehängt werden soll, mit "value" zugreifen. Und das mache ich mit "+=" und hänge also den von außen angehängten Wert hier noch mal an das Property dran. Bei "remove" mache ich das Ganze ähnlich und remove den per "value" übergebenen Delegaten einfach von meinem click-Delegaten. So, fortan kann ich jetzt hier hingehen und kann diese Sichtbarkeit hier "private" machen. Von da an kann von außen niemand mehr direkt auf den Delegaten zugreifen. Wenn wir zurückgehen in unsere Program.cs, dann sind diese Bereiche hier natürlich nicht mehr erlaubt, aber in meinem Button ist jetzt so ein Event definiert. Events erkennt man immer an diesem kleinen Blitz hier vorne. So, und an das Klick-Event kann ich jetzt mit "+=" meinen Delegaten anhängen. Wir schauen uns das Ganze mal im Debugger an. Ich führe das aus, und springe mit F11 in diese Zeile. Wenn ich jetzt F11 drücke, springt er in den add-Bereich des Events und hängt hier an diesen Delegaten im Hintergrund diesen Wert dran. Wenn ich dann hierhin gehe, kann ich jetzt einmal diesen click-Delegaten aufrufen und dann wird diese Methode ausgeführt, die hier eben an den Delegaten drangehangen wurde. Das Ganze optimieren wir jetzt noch mal ein bisschen und zwar machen wir es derart - weil wenn wir uns das hier mal angucken, dann ist da relativ viel geschrieben, was man eigentlich nicht braucht oder was der Compiler generieren könnte. Es gibt bei Properties ja die Möglichkeit, eine auto-generated Property zu erstellen, das heißt, ich schreibe einfach ein Property "get; set;", und der Compiler generiert mir im Hintergrund diesen ganzen Code. Genau sowas gibt es auch bei Events. Das heißt, wenn ich jetzt hier - das ist alles das, was wir später brauchen werden - diesen Bereich weglasse, und dann hier an dieser Stelle noch mal den Delegaten lösche, dann funktioniert das alles nach wie vor. Wenn ich gleich auf "Kompilieren" drücke, dann generiert der Compiler all das, was wir gerade hier stehen hatten, im Hintergrund für uns. Aber für uns ist es natürlich so schöner, weil wir weniger Code haben und das Konzept so einfacher aussieht. Hier unten wir das Ganze jetzt rot unterkringelt, weil ich eben jetzt keinen Zugriff mehr auf diesem Delegaten habe. Hier muss ich jetzt einfach hingehe#n und zunächst prüfen, ob das clickEvent ungleich null ist und dann gehe ich einfach hin und löse dieses clickEvent aus. So, das ist alles, und so haben wir es umgeschrieben. Jetzt haben wir mit ganz, ganz wenig Code-Zeilen ein Event geschrieben, das ausgelöst wird, wenn wir auf diesen click-Button drücken. Man könnte sich jetzt fragen: Wo ist jetzt der Unterschied zu der Version, die wir am Anfang  hatten? Nun, zum einen können wir jetzt nicht mehr von außen hingehen und z.B. sagen "b.clickEvent=null", dann wird der Compiler meckern. Man sieht das hier schon, ich kann von außen nur etwas an das Event dranhängen oder es entfernen. Und was wir vorher machen konnten, von außen dieses Event auslösen, auch das geht nicht mehr. Events kann ich nur in der Klasse auslösen. Damit haben wir quasi ein Event erstellt und einen Delegat, der jetzt eben vom Compiler generiert wird, nach außen hin gekapselt. Wenn wir später trotzdem mal in die Situation kommen, dass wir diese add- und remove-Methoden wieder brauchen, können wir das Ganze schreiben und verändern damit die Schnittstelle nicht. Wir haben uns in diesem Video angeschaut, was es für Probleme gibt, wenn wir in unserer Klasse einen Delegaten nach außen hin sichtbar machen. Man kann zum einen die Referenz löschen von außen und man kann diesen Delegaten auslösen. Ein ähnliches Problem hat man bei Feldern. Dort benutzt man Properties, um diese Felder nach außen hin zu kapseln, also den Zugriff darauf zu regulieren. Was Properties für Felder sind, sind Events für Delegates. Mit diesen Events kann ich den Zugriff auf den Delegaten einschränken. Ich habe einen add- und remove-Bereich, in dem, wenn ich an dieses Event einen Delegaten dranhängen - diesen eben intern weiter an meinen Delegaten dranhängen kann oder entfernen kann. Das Ganze Geschreibe kann ich mir auch sparen, indem ich die Kurzform benutze, dass ich einfach nur schreibe Event, Delegattyp, und Eventname, dann wird im Hintergrund vom Compiler dieser ganze Code automatisch generiert. Wenn ich so ein Event habe, habe ich keine Möglichkeiten mehr, von außen z.B. die Referenzen zu löschen oder von außen dieses Event auszulösen, das geht nur noch innerhalb meiner Klasse.

Visual C# 2011 Grundkurs

Steigen Sie in die C#-Programmierung ein und lernen Sie sowohl die Grundlagen der Sprache C# als auch die Entwicklungsumgebung Visual Studio 2010 und .NET-Framework kennen.

7 Std. 28 min (81 Videos)
Derzeit sind keine Feedbacks vorhanden...
 
Hersteller:
Software:
Visual Studio Visual Studio 2010
Exklusiv für Abo-Kunden
Erscheinungsdatum:27.06.2011

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!