Interfaces in C#

Einführung

Interfaces sind einer der Grundpfeiler der objektorientierten Programmierung in C#. Sie bieten eine Möglichkeit, Verträge innerhalb deiner Software zu erstellen und sicherzustellen, dass Klassen bestimmte Methoden oder Eigenschaften implementieren.

• Was ist ein Interface?
• Die Bedeutung von Interfaces
  • Flexibilität und Erweiterbarkeit
  • Testbarkeit
  • Wiederverwendbarkeit
• Praktisches Beispiel
• Hinweise zur Verwendung von Interfaces

Was ist ein Interface?

Einfach ausgedrückt ist ein Interface wie ein Vertrag. Dieser Vertrag legt fest, dass jede Klasse, die das Interface implementiert, auch dessen definierte Methoden und Eigenschaften implementieren muss. Im Gegensatz zu Klassen enthalten Interfaces jedoch keine Implementierungslogik. Sie definieren nur, was getan werden muss, nicht wie.

Die Bedeutung von Interfaces

Flexibilität und Erweiterbarkeit

Der Einsatz von Interfaces verleiht deinem Code Flexibilität. Da Interfaces keine Implementierung enthalten, erlauben sie es dir, mehrere Implementierungen für verschiedene Situationen zu definieren, ohne den ursprünglichen Vertrag zu ändern.

Testbarkeit

Durch den Einsatz von Interfaces kannst du Mocks oder Stubs für deine Unit-Tests erstellen, sodass du Komponenten isoliert und ohne externe Abhängigkeiten testen kannst.

Wiederverwendbarkeit

Du kannst dasselbe Interface in verschiedenen Teilen deines Projekts oder in unterschiedlichen Projekten verwenden und so sicherstellen, dass Klassen, die das Interface implementieren, über bestimmte Methoden und Eigenschaften verfügen.

Praktisches Beispiel

Im bereitgestellten Beispiel haben wir ein Interface IAuto, das eine Methode Details() deklariert. Die Klasse Auto implementiert dieses Interface und stellt damit sicher, dass die Methode Details() definiert ist.

using System;

namespace Base {
  class Interfaces {
    public void Run() {
      var auto = new Auto("Nissan", "Juke", "Vorne", "Manuell", "Diesel", 1461, 175, 110, 25070);
      auto.Details();

      /*
        Marke: Nissan
        Modell: Juke
        Motorposition: Vorne
        Getriebe: Manuell
        Kraftstoff: Diesel
        Hubraum: 1461 cc
        Höchstgeschwindigkeit: 175 km/h
        Maximalleistung: 110 PS
        Preis: 25070 Euro
      */
    }
  }

  class Auto : IAuto {
    private string marke, modell, motorposition, getriebe, kraftstoff;
    private int hubraum, hoechstgeschwindigkeit, maximalleistung;
    private double preis;

    public Auto(string marke, string modell, string motorposition, string getriebe, string kraftstoff,
                 int hubraum, int hoechstgeschwindigkeit, int maximalleistung, double preis) {
      this.marke = marke;
      this.modell = modell;
      this.motorposition = motorposition;
      this.getriebe = getriebe;
      this.kraftstoff = kraftstoff;
      this.hubraum = hubraum;
      this.hoechstgeschwindigkeit = hoechstgeschwindigkeit;
      this.maximalleistung = maximalleistung;
      this.preis = preis;
    }

    public void Details() {
      Console.WriteLine($"Marke: {marke}");
      Console.WriteLine($"Modell: {modell}");
      Console.WriteLine($"Motorposition: {motorposition}");
      Console.WriteLine($"Getriebe: {getriebe}");
      Console.WriteLine($"Kraftstoff: {kraftstoff}");
      Console.WriteLine($"Hubraum: {hubraum} cc");
      Console.WriteLine($"Höchstgeschwindigkeit: {hoechstgeschwindigkeit} km/h");
      Console.WriteLine($"Maximalleistung: {maximalleistung} PS");
      Console.WriteLine($"Preis: {preis} Euro");
    }
  }

  interface IAuto {
    void Details();
  }
}

Hinweise zur Verwendung von Interfaces

Bei der Arbeit mit Interfaces ist es wichtig, einige Punkte im Hinterkopf zu behalten:

1. Benennung: Es ist eine gängige Konvention in C#, den Namen eines Interfaces mit dem Buchstaben 'I' zu versehen, wie z. B. IAuto.
2. Einfachheit: Halte deine Interfaces einfach und fokussiert. Wenn ein Interface zu viele Member bekommt, ist es vielleicht an der Zeit, es zu refaktorieren oder aufzuteilen.

Fazit

Interfaces spielen eine entscheidende Rolle in der objektorientierten Programmierung, insbesondere in Sprachen wie C#. Sie bieten eine robuste Struktur, die die Trennung von Verantwortlichkeiten, die Wiederverwendung von Code und die Erweiterbarkeit fördert. Mit einem soliden Verständnis von Interfaces bist du in der Lage, modularere, besser testbare und wartbarere Software zu entwickeln.

Happy coding!