Betrachten wir zunächst die herkömmliche Benutzung von privaten Eigenschaften:

  1.  class Demo
  2.  {
  3.      private int privateEigenschaft;  //Eigenschaft (MS-Sprech: Field)
  4.      public void setPrivateEigenschaft(int pe)   //herkömmliche get-/set-Methoden
  5.      {
  6.          privateEigenschaft = pe;
  7.      }
  8.      public int getPrivateEigenschaft()
  9.      {
  10.          return privateEigenschaft;
  11.      }

Datenkapselung wird durch erhöhten Aufwand beim Zugriff erkauft. Es werden get- und set-Methoden benötigt. Auch deren Benutzung ist nicht etwas umständlich:

  1.  Demo demo = new Demo();
  2.  
  3.  //Aufrufe der set- und get-Methoden
  4.  demo.setPrivateEigenschaft(1);
  5.  Console.Write(demo.getPrivateEigenschaft());

Wie schön einfach ist dagegen die "schmutzige" Verwendung öffentlicher Eigenschaften:

  1. class Demo
  2. {
  3.     ...
  4.  
  5.     public int oeffentlicheEigenschaft; //öffentliche Eigenschaft (Pfui bäh)


Auf Datenkapselung wird verzichtet, aber der Zugriff erfolgt einfach direkt und unkontrolliert ohne die Verwendung von Methoden:

  1.  Demo demo = new Demo();

  3.  ...
  4.  // zum Vergleich öffentliche Eigenschaft
  5.  // (Pfui bäh, da keine Datenkapselung)
  6.  demo.oeffentlicheEigenschaft = 1;
  7.  Console.Write(demo.oeffentlicheEigenschaft); // keine get- u. set-Methode nötig

Dieses Vorgehen verbietet sich von selbst!


Properties

C# bietet uns einen 3. Weg, die sogenannten Properties (dt. Eigenschaften):

  1. class Demo
  2. {
  3.     private int privateEigenschaft;  
  4.  
  5.     public int Property   //Definition einer Property (C#-Sprech)
  6.     {
  7.         get                     //get-Accessor
  8.         {
  9.             return privateEigenschaft;
  10.         }   
  11.         set                     //set-Accessor
  12.         {
  13.             if (privateEigenschaft < 0)      //Codeergänzung möglich
  14.                 privateEigenschaft = 0;
  15.             else
  16.                 privateEigenschaft = value;
  17.         }  
  18.     }

Die Verwendung ist denkbar einfach:

  1.  Demo demo = new Demo();
  2.  ...
  3.  
  4.  //einfache Benutzung einer Property
  5.  demo.Property = 1;  
  6.  Console.Write(demo.Property);


Bei einfacher Verwendung besteht dennoch die Möglichkeit, den Zugriff mittels der sogenannten set- und get-Accessoren zu kontrollieren.


Properties (dt. Eigenschaften) sind C#-spezifisch. Eigenschaften heißen in C# field (dt. Feld). Fields, Properties und Methods nennt man in C# auch member (dt. Mitglieder) einer Klasse.


Im obigen Beispiel greift die Property noch explizit auf eine bestimmte Eigenschaft zu. Properties funktionieren aber auch ohne explizit deklarierte Eigenschaften:

  1.  class Demo
  2.  {
  3.      ...
  4.      public int Property2 { get; set; } //volle Funktionalität ohne Eigenschaft

Dabei lässt sich der Zugriff durch die Accessoren auch noch einschränken:

  1.  class Demo
  2.  {
  3.      ...
  4.      public int Property3 { get; private set; } // Einschränkung des Zugriffs

Die Verwendung von property3 ist nun nur eingeschränkt möglich:

  1.  Demo demo = new Demo();
  2.  ...
  3.            
  4.  demo.Property2 = 1;                // okay
  5.  Console.WriteLine(demo.Property2); // okay 
  6.  
  7.  demo.Property3 = 3;            // nicht möglich, da set-Accessor privat
  8.  Console.Write(demo.Property3); // funktioniert, da get-Accessor public ist

Tipp: Nutzen der Code-Vervollständigung von Visual Studio: Geben Sie z.B. prop, propfull oder propg gefolgt von einem Tabulator ein!




Last modified: Wednesday, 24 February 2021, 12:28 PM