Visual C# 2011 Grundkurs

Eigenschaften

LinkedIn Learning kostenlos und unverbindlich testen!

Jetzt testen Alle Abonnements anzeigen
Eigenschaften regeln den Zugriff auf Felder und kapseln somit die Daten. In diesem Video erfahren Sie, was Datenkapselung ist und wie man das Ganze in C# löst.
11:35

Transkript

Wir schauen uns jetzt einmal an, wie man den Zugriff auf die Daten, also auf die Felder einer Klasse mit Eigenschaften regeln kann und damit eine sogenannte Datenkapselung erreicht. Wenn man Daten in einer Klasse hat, dann sollte man unbedingt immer daran denken, dass man die von außen niemals zugreifen sollte. Wenn wir uns das mal unten rechts an einer konkreten Person, also jetzt nicht mehr unbedingt an einer Klasse vorstellen, zeigt diese Person ein Alter. Dieser Mensch wird automatisch älter, da muss niemand von außen hingehen und diese Person älter machen oder jünger machen. Machen zwar einige, aber sollte man nicht machen. Genau das gleiche ist bei der Energie. Die Energie, die steigt oder sinkt, wird intern vom Körper verwaltet, d.h. wenn ich laufe, dann sinkt die Energie, wenn ich Nahrung zu mir nehme, steigt die Energie. Bei Vornamen ist das Ganze ähnlich. Einen Vornamen bekomme ich bei der Geburt und der ändert sich danach eigentlich nicht mehr. Beim Nachnamen ist das Ganze wieder anders, der kann eben halt sich ändern, wenn man irgendwann mal heiratet. Und diese ganzen verschiedenen Arten, wie man auf Daten zugreifen müsste, muss man jetzt auf Klassen übertragen. Auch bei Klassen sollte man z.B. nicht von außen hingehen und z.B. das Alter ändern können oder die Energie ändern können, weil das alles durch diese sogenannte Verhalten also durch die Methoden der Klasse gemacht werden. Deshalb sollte man immer diese Daten in so einer genannten Datenkapsel schützen, d.h. dass ich alle Daten innerhalb von einer Klasse mit einem sogenannten Get- und Setbereich ausstatte. Get heißt, ich möchte mir den Inhalt dieser Variable bzw. dieses Feldes angucken und Set heißt, ich setze einen Bereich. Wenn Sie z.B. Alter anschauen, Alter hätte einen Getbereich, um das Alter anzuzeigen oder aus dieser Person auszulesen, aber keinen Setbereich, der von außen zugänglich ist. Energie könnte ich von außen auslesen, aber ich könnte von außen keine neue Energie setzen, das würde die Klasse intern machen. Vorname, auch dort, das könnte ich auch nicht setzen, das könnte ich maximal auslesen. Beim Nachnamen hätte ich dann einen Getter und einen Setter, weil ich muss den Nachnamen auslesen und irgendwann möchte man diesen Nachnamen vielleicht auch mal ändern. Das ist wie gesagt das Prinzip der Datenkapselung und das sollten wir in C# immer anstreben und versuchen, zu implementieren. Der erste Versuch, den wir jetzt starten können, um so ein Feld zu kapseln, in diesem Fall das Feld "Alter", ist der Einsatz von Set- und Getmethoden. Setmethoden heißt, dass ich eine Methode habe, "setfeldname", und diesem "setfeldname" übergebe ich einen Parameter, der genau den Datentyp des jeweiligen Feldes hat, und dann wird dieser übergebene Wert gesetzt. Sieht man hier links "setalter", dem übergebe ich einen Wert, das Alter wird unten mit dem Wert gesetzt. Vorher wird allerdings noch überprüft, ob dieser Wert kleiner als null ist, dann springt man aus der Methode heraus und der Wert intern wird nicht geändert, weil eben negatives Alter keinen Sinn macht. An der Stelle habe ich quasi den Zugriff auf mein dahinterliegendes Feld "Alter" reguliert. Ich habe z.B. gesagt, du darfst keinen negativen Wert annehmen. So kann ich von außen nur einen Alter-Wert festlegen, der größer als null ist. Rechts ist dann die Variante, um diesen Wert auszulesen, also "getalter", da sag ich einfach nur "Return Alter".  Das jetzt z.B. ist eine Variante, wie man es in Java machen würde, bei .NET bzw. bei C# sieht das ganze ein bisschen anders aus, weil eben genau für diese Datenkapselung gibt es unter C# ein spezielles Konstrukt, das sind die sogenannten Eigenschaften. Eigenschaften werden definiert, wie man es hier sieht. Zunächst haben wir einen Zugriffsmodifizierer, der zeigt, ob diese Eigenschaft von außen sichtbar ist oder nicht, dann den Datentyp dieser Eigenschaft, und dann den Namen. Innerhalb dieses Blocks, unter der Eigenschaft haben wir dann einen Getbereich und einen Setbereich. Wenn ich von außerhalb diesem Alter etwas zuweise, dann springt er in den Setbereich. Dort könnte ich jetzt wieder diese Überprüfung machen, ob der Wert kleiner null ist. Der übergebenen Wert, also der Wert, der dem Alter zugewiesen wird, steht in "Value". Wenn dann dieser Wert kleiner null ist, spring ich aus dieser Eigenschaft, aus diesem Set heraus, und wenn nicht, dann setze ich dieses Alter. Und als Gegenstück zu diesem "getalter" von eben, haben wir jetzt diesen Getbereich. In dem Getbereich sage ich auch nur wieder "Return Alter". So, ab diesem Punkt kann ich dieses Feld "Alter" nehmen und "private" machen, also dass es von außen nicht mehr direkt zugänglich ist, weil ich hier eine feste definierte Schnittstelle habe, mit der ich auf den Inhalt von diesem Feld "Alter" zugreife, eben mit dieser Eigenschaft "Alter". Man sieht es hier, das ist auch wieder so eine Namenskonvention. Die Eigenschaft, die nach außen sichtbar ist, die wird groß geschrieben, also "Alter" groß, und das dahinterliegende Feld beginnt mit einem Unterstrich und wird dann klein weitergeschrieben. Wie man das Ganze in C# umsetzt, schauen wir und jetzt mal an einem kleinen Beispiel an. Dazu habe ich an dieser Stelle schon einmal ein bisschen Code vorbereitet. Wir haben eine Klasse "Person". Diese Klasse "Person" hat einen Konstruktor mit zwei Komponenten, den "Vornamen" und den "Nachnamen" und die werden intern in die Felder übernommen in der Klasse. "Energie" wird auf einen Wert von 100 gesetzt und hier unten haben wir eine Klasse "Laufe", wo ich eine Strecke angeben kann, und wenn diese Person eine Strecke läuft, dann verringert sich intern die Energie. Das klappen wir einmal ein, weil das spielt jetzt gerade für uns keine Rolle. Hier haben wir die verschiedenen Felder, die wir jetzt kapseln möchten, mit unseren Eigenschaften. Wir haben "Vorname", "Nachname" vom Typ "string", "Alter", "Energie" vom Typ "int" und hat "Hunger" von Typ "boolean". Wir fangen jetzt erst mal an, das ganze auszuformulieren für nur ein Feld. Das ist hier die "Energie" und dann legen wir uns einmal so eine Eigenschaft an. Zunächst müssen wir den Zugangsmodifizierer angeben, also "public", dann den Datentyp des Feldes, das diese Eigenschaft kapselt und dann den Namen. Der Name sollte "Energie" sein, also großgeschrieben am Anfang. Jetzt haben wir natürlich bereits das Feld definiert, was so heißt und wir hatten ja mal gesagt, in den Folien, dass man das bei internen Felder so machen sollte, dass man mit einem Unterstrich beginnt und dann klein weiterschreibt. Deswegen, das ist jetzt hier der Name für unser Feld, "_", klein weiter und für unsere Eigenschaft nehmen wir "Energie" am Anfang groß geschrieben.Innerhalb von dieser Eigenschaft haben wir zwei Bereiche, zunächst den Getbereich und den Setbereich. So, und der Getbereich wird jetzt immer dann aufgerufen, wenn von außen diese "Energie" ausgelesen wird. Also müssen wir an dieser Stelle nur sagen "Return Energie", damit haben wir den Wert des Feldes "Energie" nach außen gegeben. So, hier unten können wir jetzt einfach sagen, im Setbereich, das ist der Bereich, der aufgerufen wird, wenn "Energie" von außen ein Wert zugewiesen wird, dass wir "Energie" den Wert zuweisen, der in "Value" steht, weil der "Energie" zugewiesene Wert steht hier in "Value", das ist einfach so. Wir schauen uns das Ganze einmal von draußen an. Ich habe hier eine Referenz "Ich" vom Typ "Person", die zeigt auf ein Person-Objekt mit meinem Vor- und Nachname und hier laufe ich zweimal. So, an dieser Stelle gehe ich jetzt hin und weise "Energie" mal einen Wert zu, z.B. "50" und dann geben wir an der Stelle auch nochmal den Energiewert aus. Mit "Console.RightLine", also "Ich" und "Energie" geben wir aus. Und dann schauen wir uns das Ganze mal in Debugger an, setzen hier einen Breakpoint und führen das Ganze aus. Jetzt muss man immer schauen, wenn man das das erste Mal ausführt, hier ein Rechtsklick auf diese Zeile und diese Option "Eigenschaften- Operatoren überspringen" muss auf jeden Fall deaktiviert sein. Das ist hier nach Einstellung von Visual Studio ist das manchmal aktiviert, dann funktioniert das folgende Beispiel nicht. So, jetzt kann ich an dieser Stelle mit F11, also das ist eine Zuweisung, ich weise "50" an "Energie" zu mit F11, hineinspringen. Man sieht, dann wird dieser Setbereich aufgerufen, der hineingeschriebene Wert 50 steht jetzt in "Value" und das speichere ich jetzt intern in meinem Feld. Eine Zeile später lese ich den Wert von "Energie" aus, auch hier drücke ich wieder F11, und dann gehe ich in den Getbereich und hole mit dem Wert aus dem Feld "Energie" heraus. Das war die Funktionsweise vom Get- und Setbereich. Jetzt könnte man sagen, das, was ich hier mache, also von außen die "Energie" ändern, ist eigentlich nicht gut, weil "Energie" sollte intern verwaltet werden, intern aufgeladen werden, wenn z.B. die Methode "Esse" aufgerufen wird, aber eben nicht so. Deswegen kann man bei Eigenschaften hingehen und hier sagen, der Getter und Setter sind "per default public", also von außen zugreifbar, aber ich kann z.B. beim Setter sagen, ich möchte dass der "private" ist. D.h. ich kann diesen Wert von "Energie" nur intern setzen, aber von außen nicht. Wenn ich dann wieder im Programm zurückwechsle, sehe ich hier, es ist rot unterkringelt und hier steht, dass die Eigenschaft in diesem Kontext jetzt nicht verwendet werden kann, da der Set-Exzessor, also dieser Setbereich nicht verfügbar ist. Also können wir das hier nicht mehr machen. So, wenn ich jetzt zurück in unsere Klasse "Person" gehe, kann ich hier oben den Zugriffsmodifizierer von meinem Feld "Energie" auf "private" setzen. Weil den muss ich jetzt von außen gar nicht mehr zugreifen. Ich kann jetzt, das, was ich darf, also dieses Feld auslesen, kann ich mit dem Getter machen und intern, wenn ich dieses Feld setzen möchte, kann ich den Setter z.B. benutzen oder könnte direkt auf "Energie" zugreifen, deswegen ist das ab jetzt "private". Wenn ich mir das von außen mal angucke, hier, "Ich" und dann den Punktoperator aufrufe, dann ist mein "Energie"-Feld weg. Das ist jetzt wie gesagt nicht mehr nötig. Wenn wir uns jetzt das jetzt hier mal anschauen, dann haben wir, um ein so bisschen zu erreichen, schon relativ viel Code geschrieben. Wir mussten dieses Feld schreiben, wir mussten hier einen Getbereich schreiben, einen Setbereich schreiben, der eigentlich einen Wert zurückgibt und hier einen Wert setzt. Wenn ich das jetzt für alle diese Felder hier oben machen würde, dann wäre das ein unglaublich langer Code, der im Prinzip immer dasselbe machen würde. Deswegen gibt es automatisch implementierte Eigenschaften. Wir machen das jetzt einfach mal, gut aufpassen. Wir fangen zunächst an, das hier zu löschen, danach löschen wir das hier und zu guter Letzt löschen wir das hier. Was jetzt passiert, wenn wir das mal irgendwann mal kompilieren, der Compiler erkennt: Das ist eine automatisch implementierte Eigenschaft. Dann geht er hin und legt im Hintergrund so ein Feld an und generiert diesen ganzen Code, den wir gerade vorher per Hand getippt hatten, wenn er das Programm kompiliert. Also da haben wir uns sehr viel Arbeit mit gespart. Jetzt könnte man sich denken, das hier mache ich jetzt mal weg, wenn ich so eine automatisch implementierte Eigenschaft habe, könnte ich ja auch direkt ein Feld nehmen, weil dort kontrolliere ich den Get und Setter nicht, ich habe einfach ein Feld im Hintergrund. Das ist nichts anderes als vorher. Das könnte man schon, aber man kann im späteren Projektverlauf hingehen und z.B. sagen, jetzt können nur noch die-und-die Werte gesetzt werden, also machen wir aus dieser automatisch implementierten Eigenschaft wieder eine explizit implementierte Eigenschaft und formulieren den Setter aus und begrenzen z.B. den Wert dieser Variable, die gesetzt werden kann. Nach außen hin merkt man diesen Unterschied gar nicht. Wenn jemand Ihre Klasse da benutzt hat, merkt er nicht, ob das vorher eine automatisch implementierte Eigenschaft war und jetzt eine explizit implementierte Eigenschaft, das sieht er einfach nicht. Deswegen sollte man immer, und wirklich immer, wenn man so etwas hat, mit solchen Eigenschaften arbeiten, weil man dann später noch flexibel ist. Auf Grundlage dessen können wir jetzt hier einmal eben das Ganze noch ein bisschen besser formatieren. So, und dann das hier oben dran machen und dann können wir jetzt ganz schnell aus diesen Feldern hier oben entsprechend Eigenschaften machen. Der Nachname sollte ausgelesen werden können und gesetzt werden, der Vorname sollte natürlich nur ausgelesen werden können und sollte nur von intern gesetzt werden können. Semikolons hier oben muss ich natürlich entfernen. Beim Alter ist es gleich, auch da muss ich von außen lesen könne, aber gesetzt wird nur von innen. "und hat Hunger" ebenfalls wieder so, ausgelesen werden können sollte es von außen, gesetzt werden sollte es nur von innen. Damit haben wir jetzt die Daten, die vorher in unserer Klasse waren, durch solche Eigenschaften nach außen hin gekapselt und haben den Zugriff auf diese Variablen geregelt. Wir haben uns in diesem Video mal angeschaut, wie man Daten kapseln kann. Daten kapsle ich so, dass ich meine Felder, die ich in den Klassen habe, nach außen hin mit Eigenschaften schütze und somit kapsle. Bei Eigenschaften habe ich einen Getbereich, einen Setbereich. Der Getbereich wird ausgeführt, wenn diese Eigenschaft von außen ausgelesen wird, und der Setbereich wird ausgeführt, wenn diese Eigenschaft von außen irgendeinen Wert zugewiesen bekommt. Der Get- und Setbereich können verschiedene Sichtbarkeiten haben, also ich kann also einen "public" Getbereich haben und einen "private" Setbereich, damit hätte ich eine nach außen hin schreibgeschützte Eigenschaft. Zusätzlich haben wir gesehen, dass man diese ganzen Eigenschaften, explizit formuliert und explizit programmiert, ist es sehr viel Schreibarbeit. Deswegen gibt es die automatisch implementierten Properties. Dort können wir das Ganze sehr abkürzen und im Hintergrund wird vom Compiler der restlich benötigte Code generiert.

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!