Implementieren einer Eigenschaft in einer Schnittstelle in C#

1. Verwenden Sie einen einfachen Codeblock, um Eigenschaften in einer Schnittstelle festzulegen
2. Änderungen an Eigenschaften in einer Schnittstelle in C#
3. Implementieren Sie eine Eigenschaft mit mehrfacher Schnittstellenvererbung in einer abstrakten Klasse
4. Fazit

Heute lernen wir, wie man Eigenschaften in einer Schnittstelle in C# implementiert.

Schnittstellen in C# können viele verschiedene Eigenschaften haben, zusammen mit den Zugriffsmodifikatoren, die angeben, wie wir die Verfügbarkeit von Eigenschaften innerhalb deklarieren sollten. Die Schnittstelle fungiert häufig als Standardimplementierung verschiedener Member und Objekte.

Beginnen wir mit den verschiedenen Möglichkeiten, wie wir Eigenschaften in einer Schnittstelle implementieren können.

Verwenden Sie einen einfachen Codeblock, um Eigenschaften in einer Schnittstelle festzulegen

Nehmen wir an, wir erstellen in C# eine Schnittstelle namens ENGINE mit der Eigenschaft TORQUE. Wir stellen die Schnittstelle ENGINE wie folgt ein:

public interface ENGINE {
  int torque { get; set; }
}

Daher haben wir eine Schnittstelle mit einem geeigneten Getter und Setter für ihre Eigenschaft namens TORQUE erstellt. Um die Schnittstelle zu verwenden, müssen wir eine Klasse definieren, die diese Schnittstelle implementieren kann.

Nehmen wir an, wir wollen eine Klasse CAR definieren, die einen ENGINE enthält. Daher können wir etwas wie folgt schreiben:

class CAR : ENGINE {
  public int torque { get; set; }
}

Beachten Sie, dass die Klasse CAR eine Implementierung von TORQUE zur öffentlichen Verwendung enthält, wenn Sie ein Objekt aus dieser Klasse erstellen. Um das Objekt CAR zu verwenden, rufen Sie einfach etwas wie folgt auf:

CAR x = new CAR();
x.torque = 989;
Console.WriteLine(x.torque);

Daher können Sie verschiedene Eigenschaften verwenden und in die später zu verwendende Schnittstelle aufnehmen. Dies bietet eine bessere Abstraktionsebene und ermöglicht Modifikationen, ohne die Hauptmethoden oder -klassen zu ändern.

Wenn wir also eine neue Eigenschaft namens LABEL zu ENGINE hinzufügen wollten, könnten wir sie in der Schnittstelle ENGINE setzen, die in der Klasse CAR verwendet werden kann.

Der gesamte Code würde wie folgt aussehen:

using System;

namespace CA_ONE {
  class Program {
    public interface ENGINE {
      int torque { get; set; }
    }

    class CAR : ENGINE {
      public int torque { get; set; }
    }

    static void Main(string[] args) {
      CAR x = new CAR();
      x.torque = 989;
      Console.WriteLine(x.torque);
    }
  }
}

Wir haben unser Projekt CA_ONE genannt; daher erweitert und implementiert der Namensraum ihn. Eine weitere Sache, die hier zu beachten ist, ist, dass die Implementierung von TORQUE in CAR andere Definitionen innerhalb ihrer Funktion haben kann, wie z. B. eine PRINT-Methode oder eine Drehmomentumwandlung usw.

Änderungen an Eigenschaften in einer Schnittstelle in C#

In der oben bereitgestellten Lösung haben wir erwähnt, wie wir andere Methoden innerhalb unserer Implementierung definieren könnten. Angenommen, wir möchten die Methoden GET und SET erweitern, die standardmäßig in der Schnittstelle ENGINE definiert sind.

Wir lassen ENGINE unberührt, neigen aber dazu, den Code innerhalb der Klasse CAR zu ändern, die ihn erweitert.

Wenn wir in CAR ein TORQUE einstellen, möchten wir möglicherweise auch "Torque is Set to _value_" drucken, damit unser Benutzer weiß, ob die Eigenschaft TORQUE richtig eingestellt wurde oder nicht.

Wir können daher fortfahren und Folgendes tun:

class CAR : ENGINE {
  private int torque_priv;
  public int torque {
    get { return this.torque_priv; }
    set {
      this.torque_priv = value;
      Console.WriteLine("This torque has been set to " + torque_priv);
    }
  }
}

Konzentrieren wir uns hier nun darauf, was im Code passiert. Das erste, was uns auffällt, ist die Verwendung einer anderen Variablen namens TORQUE_PRIV.

Wir haben es instanziiert, weil wir den im folgenden Code übergebenen TORQUE-Wert speichern müssen:

x.torque = 989;

Wenn Sie stattdessen die Variable TORQUE_PRIV nicht verwenden, bleibt der Code in einer Schleife hängen und bewegt sich rekursiv, um den Wert der Eigenschaft TORQUE zuzuweisen. Außerdem haben wir hier etwas namens VALUE verwendet.

Beachten Sie, dass VALUE keine Variable, sondern ein kontextabhängiges Schlüsselwort in C# ist. VALUE wird im Set-Indexer in Eigenschafts- und Zugriffsdeklarationen verwendet.

Es nimmt den vom Client zugewiesenen Wert und weist ihn der privaten Variablen der Klasse zu. Auf diese Weise können Sie Ihre Deklarationen ändern und verwenden.

Viele Leute werden den folgenden Code im Setter von TORQUE für das abstrakte CAR verwenden.

this.torque_priv = torque;

Und für den GETTER:

return torque;

Dies wird einen Fehler wie folgt darstellen, da er in einer rekursiven Schleife hängen bleibt:

Stack overflow.

Die allgemeine Syntax zum Implementieren einer beliebigen Eigenschaft in einer Schnittstelle lautet wie folgt:

type name { get; set; }

Da mehrere Klassen Schnittstellen erben und verwenden können, ist es besser, Eigenschaften in den abstrakten Klassen zu erweitern und zu ändern. Schnittstellen können als Rückgratstruktur bei der Implementierung verschiedener Methoden dienen und eine grundlegende Vorstellung davon vermitteln, was erweitert werden soll und was nicht.

Denken Sie daran, dass Schnittstellen nicht einfach verwendet werden können. Sie müssen abstrakte Klassen haben, die initialisiert und verwendet werden, während ein Code ausgeführt wird.

Methoden in einer Schnittstelle sind immer öffentlich, und es ist kein impliziter Zugriffsmodifikator erforderlich. Außerdem können Schnittstellen von anderen Schnittstellen erben.

Wenn Sie versuchen, eine Eigenschaft in einer Schnittstelle zu implementieren, und eine andere Schnittstelle die zuvor definierte erbt, können Sie eine Klasse verwenden, um die letztere Schnittstelle zu erweitern.

Nehmen wir an, wir haben eine Schnittstelle ENGINE, die BOLTS erbt und dann von der Klasse CAR geerbt wird. Wir wollen für jedes CAR ein Emergency Kit mit der Schlüsselweite gemäss Bolzendimension einbauen.

Daher können wir eine Implementierung wie folgt verwenden:

public interface BOLT {
  int size { get; set; }
}

public interface ENGINE : BOLT {
  int torque { get; set; }

Und dann den BOLT in der Klasse CAR wie folgt erweitern:

public int size {
  get { return wrench_size; }
  set {
    // set the wrench size
    wrench_size = value;
    Console.WriteLine("The wrench size to use should be: " + wrench_size);
  }
}

Sie können also sehen, dass alle Schnittstellen vererbt werden. Wenn Sie eine Eigenschaft in einer Basisschnittstelle festlegen, müssen Sie diese Eigenschaft in allen Klassen implementieren, die entweder die Basisschnittstelle oder die abgeleiteten Schnittstellen erweitern.

Daher ist es notwendig, die Definitionen zu erweitern.

Implementieren Sie eine Eigenschaft mit mehrfacher Schnittstellenvererbung in einer abstrakten Klasse

Nehmen wir an, wir haben zwei Schnittstellen: ENGINE und WHEEL. Und beide enthalten eine Startmethode, die uns mitteilt, ob der ENGINE oder WHEEL gestartet wurde oder nicht.

Lassen Sie uns eine Startmethode definieren.

public interface WHEEL {
  void print();
}

public interface ENGINE : BOLT {
  int torque { get; set; }
  void print();
}

Um es in der Klasse CAR zu erweitern, müssen Sie einige Funktionen wie folgt schreiben:

void WHEEL.print() {
  Console.WriteLine("Wheel has been started");
}
void ENGINE.print() {
  Console.WriteLine("Engine has been started!");
}

Und um sie anzurufen, schreiben Sie in der Hauptsache Folgendes:

((WHEEL)x).print();

Hier legen Sie fest, auf welcher Schnittstelle Sie die Methode print() verwenden möchten.

Greifen Sie hier auf den vollständigen Code zu, der in diesem Tutorial verwendet wird.

Fazit

Das ist alles für die Verwendung von Eigenschaften in Schnittstellen. Es kann verschiedene Umstände geben, unter denen wir eine Eigenschaft festlegen und verwenden müssen; daher ist es besser, alle oben beschriebenen Fälle zu untersuchen.