[C#] Vorteil und Verwendung von Interfaces

Drucken
( 15 Votes )
Hauptkategorie: Programmieren Kategorie: C#
Erstellt am 29.02.2012 Zuletzt aktualisiert am 29.02.2012 Geschrieben von Jonny132
In diesem Tutorial erkläre ich euch die Funktionsweise und den Vorteil den Interfaces bieten.
Ein Interface ist eigentlich nichts anderes als eine Strukturbeschreibung. Das Interface definiert welche Properties und Methoden eine Klasse haben muss, sollte die Klasse vom Interface abgeleitet sein.

Am anschaulichsten wird das am besten in dem ich euch ein Beispiel zeige.
Erstellt dazu einfach eine Leere Windows - Forms Anwendung und wechselt zugleich in die Codeansicht.

Zuerst erstellen wir nun direkt in der Form Klasse ein Interface.
    private interface ILebewesen
    {
      string Name {get; set;}
      string Typ { get; }
      string Eigenschaft { get; }
    }
Wie ihr seht ist das Interface nicht sehr groß, sollte aber deutlich machen was damit gemeint ist. Da Interfaces meistens einen Oberbegriff für etwas darstellen, habe ich mir das Lebewesen ausgesucht. Ein Lebewesen hat nun bestimmte Eigenschaften. Welche mir spontan eingefallen sind zB der Typ (Ein Lebewesen kann beispielsweise ein Mensch, Hund oder Katze sein), einen Namen für das Lebewesen) und eine Eigenschaft die das Lebewesen hat. Diese Liste könnte man natürlich noch weiterführen und Detaillierter machen.

Bleiben wir gerade bei den gerade Angesprochenen Lebewesentypen für Mensch, Hund und Katze. Somit erstellen wir zuerst eine Klasse "Mensch" die das Interface ILebewesen implementiert. Schreibt zuerst den Rump der Klasse. 
   private class Mensch : ILebewesen
   {
   }
Würdet ihr jetzt versuchen, das Projekt zu kompilieren, würde der Debugger gleich meckern und euch mitteilen, dass das Interface nich komplett implementiert wurde.

Visual Studio erleichtert euch das implementieren von Interfaces indem Ihr einen Rechtsklick auf das Interface der Klasse macht und "Implement Interface" auswählt.


Nun wird automatisch der ganze Code für das Interface implementiert, nun müsst ihr nurnoch die Eigenschaften zuweisen. Die Klasse "Mensch" habe ich folgendermassen implementiert:
    private class Mensch : ILebewesen
    {
      public Mensch(string name)
      {
        this.Name = name;
      }

      public string Name{ get; set; }

      public string Typ
      {
        get { return "Mensch"; }
      }

      public string Eigenschaft
      {
        get { return "redet"; }
      }
    }
Somit können wir ein Objekt vom Typ "Mensch" erstellen und ihm einen Namen zuweisen.

Erstellen wir nun noch die Klassen "Hund" und "Katze", die vom Prinzip genau gleich aussehen:

    private class Hund : ILebewesen
    {
      public Hund(string name)
      {
        this.Name = name;
      }

      public string Name { get; set; }

      public string Typ
      {
        get { return "Hund"; }
      }

      public string Eigenschaft
      {
        get { return "bellt"; }
      }
    }


    private class Katze : ILebewesen
    {
      public Katze(string name)
      {
        this.Name = name;
      }

      public string Name { get; set; }

      public string Typ
      {
        get { return "Katze"; }
      }

      public string Eigenschaft
      {
        get { return "miaut"; }
      }
    }
Dieser Code dürfte nun eigentlich selbsterklärend sein, doch wozu das Ganze?
Welchen Vorteil bietet mir diese implementation?
Ich versuche euch das mit einem kleinen Codebeispiel zu veranschaulichen.
    public Form1()
    {
      InitializeComponent();

      List<ILebewesen> lebewesen = new List<ILebewesen>();
      lebewesen.Add(new Hund("Bello"));
      lebewesen.Add(new Mensch("Peter"));
      lebewesen.Add(new Katze("Lady"));
      lebewesen.Add(new Hund("Kira"));
      lebewesen.Add(new Hund("Bonka"));

      foreach (ILebewesen wesen in lebewesen)
      {
        MessageBox.Show("Der/Die " + wesen.Typ + " " + wesen.Eigenschaft + " und heisst " + wesen.Name); 
      }
    }
Und zwar erstellen wir im Konstruktor der Form1 eine Liste die Objekte enthält die das Interface ILebewesen implementiert haben.
Dieser Liste fügen wir ein paar Testobjekte hinzu.

Der große Vorteil ist nun, dass wir über die ganze Liste iterieren können, und da der Compiler nun weiss, dass es ein Lebewesen ist, hat er ebenso die Information welche Eigenschaften und Methoden diese Lebewesen besitzen und kann diese Aufrufen.

In der Praxis werden Interfaces oft verwendet wenn mehrere Programmierer am Projekt beteiligt sind. Somit kann der erste Programmierer dem zweiten ein Interface zur Verfügung stellen, diese der zweite in seine Klassen einbinden muss, ohne dass der erste Programmierer Details über die Klassen von dem zweiten Programmierer kennen muss und kann trotzdem auf die Funktionalität der Klassen zugreiffen.

Veröffentlichen Sie ihre Kommentare ...