C# Properties einfach erklärt
In diesem Tutorial sprechen wir über C# Properties (Eigenschaften). Als einleitender Satz lässt sich wohl am besten sagen, dass man sich Eigenschaften wie eine andere Art von Variablen vorstellen kann. Eigenschaften können Getter- und Setter Methode verwenden und werden für die objektorientierte Programmierung verwendet werden.
Schauen wir uns zuerst mal zwei ganz normale Variable an:
public int age = 18; // Public
private string password; // PrivateDie beiden Variablen weisen verschiedene Zugriffsmodifizierer auf. Die Variable age ist öffentlich verfügbar und kann daher von überall gelesen und gesetzt werden. Die Variable password ist private und kann daher nur von innerhalb der selben Klasse gelesen und gesetzt werden.
public → öffentliches lesen/schreiben
private → lesen/schreiben nur in der selben Klasse
Bis zum jetzigen Zeitpunkt sind noch keine Eigenschaften in Sicht, und das mit voller Absicht. Eigenschaften zu verstehen klappt am besten, wenn man die Verwendung versteht.
Das Problem
Mit Sicherheit kannst du dir vorstellen, dass es Felder (Variablen) gibt die man besser nicht verändern sollte. Readonly is hier das korrekte Wort. Stell dir vor du hast die folgende Klasse in deiner Anwendung:
public class Person {
public int yearOfBirth = 1980;
// Konstruktor
public Person(int yearOfBirth) {
this.yearhOfBirth = yearOfBirth;
}
}Das Geburtsjahr ein Menschen ändert sich normalerweise nicht, daher sollte der Wert nach dem initialisieren durch den Konstruktor nicht mehr verändert werden können.
Folgenden Code ist derzeit möglich (sollte es aber nicht sein):
public class Program {
public static void Main() {
Person newPerson = new Person(1970); // Korrektes Geburtsjahr
newPerson.yearOfBirth = 2125; // Fake
newPerson.yearOfBirth = 1645; // Fake
Console.WriteLine(newPerson.yearOfBirth);
}
}Wie können wir also verhindern, dass das öffentliche Feld yearOfBirth nicht mehr verändert werden kann? Wir könnte es natürlich auf private setzen aber dann würde die Zeile mit dem Console.WriteLine(newPerson.yearOfBirth); einen Error werfen.
Zugriffskontrolle mit C# Properties
Der korrekte Lösungsansatz ist es, yearOfBirth als eine Property zu definieren:
public class Person {
public int YearOfBirth {get; set;}
// Konstruktor
public Person(int yearOfBirth) {
this.YearhOfBirth = yearOfBirth;
}
}Genau wie Methoden werden auch Properties groß geschrieben. Sie haben außerdem auch die geschweiften Syntax Klammern. Innerhalb der Klammern lässt sich beschreiben, wie man auf die Methode Zugreifen kann.
In dem Beispiel oben erlauben wir ein öffentliches get (holen des Wertes) und ein öffentliches set (setzen des Wertes).
Auch jetzt können wir immer noch von überall den Wert der Property YearOfBirth setzen. Wir haben also noch nichts gewonnen.
Private set
Als nächstes beschränken wir jetzt den set Zugriff mit private:
public class Person {
public int YearOfBirth {get; private set;} // set ist auf private
// Konstruktor
public Person(int yearOfBirth) {
this.YearhOfBirth = yearOfBirth;
}
}Unser get bleibt weiterhin unverändert öffentlich aber das set wird mir private so beschränkt, dass der Wert jetzt nur noch von innerhalb der selben Klasse verändert werden kann. Damit haben wir den Status “readonly” erhalten.
Folgender Codes passiert mit dem Code (achte darauf, dass die Property groß geschrieben wird):
public class Program {
public static void Main() {
Person newPerson = new Person(1970); // Korrektes Geburtsjahr
newPerson.YearOfBirth = 2125; // ERROR
newPerson.YearOfBirth = 1645; // ERROR
Console.WriteLine(newPerson.yearOfBirth); // Läuft weiterhin durch readonly
}
}C# Properties haben noch weitere Funktionalitäten. Du kannst einen Standardwertsetzen und anstatt get; set; zurückzugeben sogar ganze Methodenblöcke returnen. Wenn du noch mehr über Properties Wissen möchtest, dann schau mal hier.
