C# Tutorial [17/17] – C# Attribute bzw. Eigenschaften in der Praxis

1.2. Die Set-Methode

Auch der Name der Set-Methode verrät bereits, wofür wir diese verwenden. Nämlich, um den Wert zu „setzen“, also ihn zu überschreiben.

Wenn wir also der Variable einen Wert zuweisen möchten, machen wir das über die Set-Methode.

2. Beispiel: Die Klasse Auto definieren

In diesem Beitrag möchte ich dir das ganze Konzept nun in der Praxis demonstrieren. So erfährst du, wie es in Visual Studio aussieht und wie du es dort auch selbst umsetzen kannst.

Fangen wir also zunächst einmal mit der Definition einer einfachen Klasse an. Wir erstellen nun beispielhaft eine Klasse, die wir Auto nennen. Mit dieser Klasse möchten wir Autoobjekte modellieren. Hierfür beginnen wir mit einer automatisch implementierten Eigenschaft.

2.1. Automatisch implementierte C# Attribute / Eigenschaften erstellen

Man kann in C# Attribute zum einen auf eine schnelle Art und Weise definieren, sie aber zum anderen auch komplett ausschreiben.

Automatisch implementierte C# Attribute bzw. Eigenschaften sind die schnelle Art und Weise, so etwas umzusetzen. Sie sehen folgendermaßen aus:

Wie du auf dem Bild erkennen kannst, erstellen wir zunächst eine Eigenschaft, die public und vom Typ String ist. Wir nennen diese Hersteller. Hierein möchten wir nun immer den Herstellernamen des Autoobjekts schreiben.

Zu einer automatisch implementierten Eigenschaft machen wir diese, indem wir nach „Hersteller“ ein geschweiftes Klammerpaar setzen, in das wir get und set schreiben. Damit haben wir die Eigenschaft bzw. das Attribut Hersteller erstellt.

An dieser Stelle können wir zurück zur Main-Methode kehren und ein neues Objekt vom Typ Auto erstellen. Das heißt, wir erstellen eine Variable vom Typ Auto, die wir beispielhaft auto1 nennen. Den Hersteller von auto1 setzen wir auf „Supercars“ und lassen diesen in der Konsole ausgeben:

In der Konsole sehen wir: Das Programm gibt uns „Supercars“ aus. Es funktioniert also einwandfrei.

Das Programm ruft mit der Zeile „auto1.hersteller = Supercars“ die set-Methode auf, welche den Wert setzt.

In der Zeile „Console.WriteLine(auto1.hersteller)“, in der wir den Wert lesen und ausgeben lassen möchten, ruft das Programm die get-Methode auf.

An dieser Stelle möchte ich dir zeigen, dass man in Bezug auf C# Attribute nicht unbedingt einen Setter verwenden muss. Wir können also beispielsweise den Setter entfernen:

Nun sehen wir, dass wir nicht mehr die Möglichkeit haben, den Wert zu setzen:

Das Lesen funktioniert allerdings noch. Der Wert ist sozusagen noch „read only“, was bedeutet: Wir können ihn von außen nicht mehr setzen, sondern nur noch von innerhalb der Klasse Auto.

Den Wert kann ich jetzt zum Beispiel auf „Supercars“ setzen:

Wenn wir die Zeile „auto1.Hersteller = Supercars“ löschen und an dieser Stelle den Wert von auto1 auslesen, sehen wir auch hier in der Konsole „Supercars“.

Jetzt ist es allerdings so, dass der Wert „Supercars“ in jedem Objekt vom Typ auto stehen würde. Das liegt daran, dass wir ihn direkt in der Klasse setzen. Ich wollte damit also nur demonstrieren, dass man den Setter auch weglassen und infolgedessen diesen Wert nicht mehr von außen manipulieren kann.

Gleiches kann man auch erreichen, wenn man den Setter private macht:

Damit kann man nicht mehr von außen auf den Setter zugreifen, man hat allerdings noch die Möglichkeit, das von innen zu tun. Wenn wir also beispielsweise nur ein einziges Mal den Wert von Hersteller von außen setzen möchten, könnten wir das über den Konstruktor machen. Diesen können wir definieren und ihm den String Hersteller übergeben.

Anschließend können wir in dieser Klasse im Konstruktor den Wert von Hersteller auf hersteller setzen.

Das würde dann funktionieren, denn das „private set;“ ist von innerhalb der Klasse verfügbar. Das bedeutet: Man kann von innen darauf zugreifen. Von außen geht das allerdings nicht. Wir könnten also nicht schreiben: „auto1.Hersteller = „Supercars“.

Wie du in der folgenden Abbildung siehst, erhalten wir in diesem Fall einen Fehler, der uns sagt:

„Die Eigenschaft oder der Index autohersteller kann in diesem Kontext nicht verwendet werden, da nicht auf den Set-Accessor zugegriffen werden kann.“

Wir können und müssen dann aber über den Konstruktor den Wert auf Supercars setzen:

Wenn wir das nun wieder auf der Konsole ausgeben lassen, sehen wir, dass es funktioniert:

Hier steht nun wieder der Wert Supercars.
So viel zu den automatisch implementierten Eigenschaften. Ich entferne den Konstruktor noch einmal und ändere das set wieder zu public.

Wie du gesehen hast, müssen wir hier weder eine eigene private Variable anlegen noch get und set vollständig ausschreiben.

Jetzt gibt es allerdings auch die Möglichkeit, get und set auszuschreiben und eigene Logik zu implementieren. Wie man auf dem herkömmlichen Weg, also auf die vollausgeschriebene Art und Weise eine Eigenschaft erstellt, möchte ich dir nun einmal demonstrieren.

2.2. Voll ausgeschriebene C# Attribute / Eigenschaften erstellen

Wir erstellen jetzt also eine Eigenschaft, die wir AnzahlTüren nennen. Jedes Auto hat schließlich Türen, durch welche man dieses betreten kann.

Um eine voll ausgeschriebene Eigenschaft zu erstellen, benötigen wir natürlich zuerst eine private Variable, die den Wert der Eigenschaft beinhaltet. Auf diese private Variable kann man nur von innerhalb dieser Klasse zugreifen.

Wir erstellen diese private Variable, indem wir „private“ schreiben. Sie soll vom Typ Integer sein und kleingeschrieben den Namen anzahlTüren haben. Warum kleingeschrieben? Weil es sich hierbei um eine normale Variable handelt.

Man schreibt in C# Attribute groß und normale Variablen klein.

Deklarieren wir diese also einfach mal.

Die private Variable anzahlTüren vom Typ Integer möchten wir dann über eine Eigenschaft kapseln. Das heißt, wir erstellen direkt eine Eigenschaft, also ein Attribut, das wir auf public setzen und ebenfalls AnzahlTüren nennen.

Da man in C# Attribute großschreibt, habe ich das auch bei diesem Namen getan.

Eine Eigenschaft ist ein Konstrukt aus einer privaten Variable, die wir hier bereits angelegt haben, sowie einem Getter und Setter. Diese get- und set-Methoden können wir jetzt in einem geschweiften Klammerpaar definieren.

Fangen wir dabei zuerst einmal mit dem Getter an.

Dazu schreiben wir das Schlüsselwort get gefolgt von einem Codeblock. Du hast es ja bereits gelernt: 

Der Getter gibt den Wert der privaten Variable zurück.

Das heißt, wir können darin lediglich „return“ und anschließend anzahlTüren schreiben, um so von der privaten Variable den Wert zurückzugeben.

Auf diese Art kann man den Wert über den Getter von AnzahlTüren lesen.

Danach erstellen wir noch einen Setter. Hierfür schreiben wir set und bilden einen Codeblock.

Im Setter möchten wir den Wert der privaten Variable setzen.

Das funktioniert, indem wir anzahlTüren = value schreiben.

Value beinhaltet den Wert, den wir hineinschreiben möchten. So können wir also weiter oben im Code den Parameter des Konstruktors entfernen und in der Main-Methode noch mal ein Auto erstellen. Dessen Hersteller setzen wir auf den Wert Supercars. Wenn wir jetzt auf die Eigenschaft anzahlTüren zugreifen und beispielsweise den Wert 4 hineinschreiben, ruft das Programm den Setter auf.

Der Wert von value ist 4. Das heißt, beim Setzen des Wertes wird folgendes ausgeführt:

Dadurch erhält value den Wert vier. Denn das ist schließlich der Wert, den wir zuweisen möchten. Um zu demonstrieren, dass der Setter aufgerufen wird, schreibe ich im Setter „Console.WriteLine(„Der Setter wurde aufgerufen“) und starte das Programm:

Wie wir sehen, hat das Programm den Setter tatsächlich aufgerufen, weil wir den Wert auf vier gesetzt haben. Wir können nun noch den Getter aufrufen und den Wert lesen, indem wir Console.WriteLine(auto1.AnzahlTüren) schreiben und diesen Code ausführen.

Der Code funktioniert folgendermaßen: Das Programm springt zunächst in den Getter und gibt mit return die Anzahl an Türen zurück. Demonstrieren lässt sich die Ausführung beispielsweise mit dem Text „Der Getter wurde aufgerufen“:

Wenn wir das Programm jetzt starten, sehen wir, dass es den Setter zuerst aufruft. Dort haben wir die Anzahl der Türen auf vier gesetzt. Anschließend gibt es den Hersteller aus und danach möchten wir die Anzahl der Türen in der Konsole sehen. Es gibt also zuerst den Satz „Der Getter wurde aufgerufen“ aus und dann die vier.

Damit hast du gesehen, dass wir in den Getter und Setter jeweils noch eigene Logik einbauen können, um so den Zugriff kontrolliert ablaufen zu lassen.

Wir können also beispielsweise loggen, wann auf welche Eigenschaften zugegriffen wurde. Wenn wir anzahlTüren auf einen negativen Wert oder 0 setzen möchten, dann setzen wir es zumindest auf 1, denn ein Auto hat schließlich immer mindestens eine Tür, über die man es betreten kann. Im Setter könnte das zum Beispiel folgendermaßen aussehen:

Hier prüfen wir, ob wir einen Wert zuweisen, der kleiner als 1 ist. Wenn dem so ist, möchten wir wenigstens den Wert 1 zuweisen, da es sonst keinen Sinn ergeben würde.

Wenn das nicht der Fall ist, weisen wir an dieser Stelle einfach den gewünschten Wert zu.

Wir können nun noch einmal oben im Code die Herstellerausgabe entfernen und anzahlTüren auf vier belassen.

Wenn wir nun diese Anzahl an Türen ausgeben lassen möchten, sehen wir, dass das Programm den Getter aufruft und vier tatsächlich hinzufügt:

Möchten wir nun aber -4 zuweisen, ruft das Programm den Getter auf, schreibt allerdings die 1 hinein. Das liegt daran, dass wir mit der -4 einen unlogischen Wert zuweisen wollten. Der Setter hat in diesem Fall das Ganze automatisch auf einen logischen Wert gesetzt.

An dieser Stelle sind wir auch schon am Ende des heutigen Beitrags angekommen. Du hast gelernt, wie Getter und Setter funktionieren und ich habe dir gezeigt, wie man sowohl automatisch implementierte Eigenschaften als auch voll ausgeschriebene Eigenschaften in C# erstellt.

In den meisten Fällen reichen uns automatisch implementierte Eigenschaften vollkommen aus. Solltest du jedoch einmal die Not haben, eigene Logik in Getter und Setter mit einzubauen, weißt du nun, wie das funktioniert.