So implementieren Sie Polymorphismus in C #

Polymorphismus bezieht sich auf die Fähigkeit, dieselbe Schnittstelle für verschiedene Formen darzustellen. Obwohl das Konzept des Polymorphismus in allen Programmiersprachen, die ihn unterstützen, dasselbe ist, unterscheidet sich seine Implementierung von einer Sprache zur anderen.

Die drei Arten des Polymorphismus sind Überladung, parametrisch und Inklusion. Polymorphismus trägt zur Förderung der Flexibilität bei Designs bei, indem dieselbe Methode unterschiedliche Implementierungen aufweist. Im Wesentlichen können Sie den Polymorphismus nutzen, um die Schnittstelle von der Implementierung zu trennen. Es fördert die Wiederverwendung von Code und die Trennung von Bedenken in Ihrer Anwendung.

Überladender Polymorphismus ist ein Typ, der in voneinander unabhängigen Klassen existiert - sie sind in keiner Weise miteinander verbunden (Vererbung, Abhängigkeit usw.). Beispielsweise können Sie zwei unterschiedliche Klassen haben, die in keiner Weise miteinander verbunden sind und eine Methode mit demselben Namen haben. Die Überladung von Operatoren ist ein Beispiel für diese Art von Polymorphismus.

Parametrischer Polymorphismus oder Vorlagenpolymorphismus ist ein Typ, bei dem Sie mehr als eine Methode in Ihrer Klasse mit identischen Namen, aber unterschiedlichen Parametern haben, dh alle haben dieselben Methodennamen, unterscheiden sich jedoch in den Parametern.

Einschlusspolymorphismus wird auch als Neudefinition oder Überschreiben von Methoden bezeichnet. Bei dieser Art von Polymorphismus kann eine Unterklasse eine Methode der Basisklasse neu definieren. Diese Fähigkeit wird auch als Spezialisierung bezeichnet.

Parametrischer Polymorphismus

Dies bezieht sich auf die Form des Polymorphismus, bei der Sie mehr als eine Methode in Ihrer Klasse haben, die denselben Namen hat, sich jedoch in ihren Methodensignaturen unterscheidet. Eine Methodensignatur besteht aus dem Rückgabetyp der Methode, dem Typ der Parameter für die Methode und der Reihenfolge dieser Parameter. Daher unterscheidet sich eine Methode, die eine Ganzzahl und ein Zeichen als Argument akzeptiert, in der Signatur von einer anderen Methode, die ein Zeichen und eine Ganzzahl als Argumente akzeptiert, obwohl die Rückgabetypen dieser beiden Methoden (mit identischen Methodennamen) identisch sind. Der Compiler bestimmt die genaue aufzurufende Methode, indem er die Methodensignaturen der überladenen Methoden vergleicht.

Die folgende Codeliste zeigt, wie das Überladen von Methoden implementiert werden kann.

public enum Severity

    {

        Informational, Warning, Critical

    }

    public class Logger

    {

        public void Log(string message)

        {

            //Some code

        }

        public void Log(string message, Severity severity)

        {

            //Some code

        }

    }

Siehe die obige Codeliste. Beachten Sie, wie die Log () -Methode überladen wurde. Dies ist ein Beispiel für den Polymorphismus zur Kompilierungszeit.

Einschlusspolymorphismus

Einschlusspolymorphismus oder Methodenüberschreibung kann in C # mithilfe virtueller Methoden erreicht werden. Beim Überschreiben von Methoden sind Methoden mit identischen Signaturen sowohl in der Basisklasse als auch in den abgeleiteten Klassen vorhanden. Normalerweise möchten Sie virtuelle Methoden verwenden, um Laufzeitpolymorphismus oder späte Bindung zu implementieren. Beachten Sie, dass eine virtuelle Methode in der Basisklasse als virtuell deklariert ist und Sie den Unterklassen des Typs erlauben können, die virtuelle (n) Methode (n) zu überschreiben.

Das folgende Codefragment zeigt zwei Klassen - die Basisklasse mit dem Namen Logger, die eine virtuelle Methode namens Log enthält, und eine abgeleitete Klasse mit dem Namen FileLogger, die die Logger-Klasse erweitert und die Log-Methode der Basisklasse überschreibt.

public class Logger

    {

        public virtual void Log(string message)

        {

            Console.WriteLine("Inside the Log method of the base class Logger");

        }

    }

    public class FileLogger : Logger

    {

        public override void Log(string message)

        {

            Console.WriteLine("Inside the Log method of the FileLogger class");

        }

    }

Dies ist ein Beispiel für das Überschreiben von Methoden. Sowohl die Basis- als auch die abgeleitete Klasse haben dieselbe Methode mit identischen Signaturen. Wir verwenden das Überschreiben von Methoden, um Laufzeitpolymorphismus oder späte Bindung zu implementieren. Das folgende Codeausschnitt zeigt, wie die Log-Methode unter Verwendung einer Referenz der Basisklasse aufgerufen werden kann.

static void Main(string[] args)

        {

            Logger logger = new FileLogger();

            logger.Log("Hello World!");

            Console.ReadKey();

        }

Wenn Sie das obige Codefragment ausführen, wird die Log-Methode der abgeleiteten Klasse, dh die Filelogger-Klasse, aufgerufen. Wenn die Log-Methode in der Basisklasse nicht als virtuell deklariert worden wäre, wäre stattdessen die Basisversion der Log-Methode aufgerufen worden. Da diese Bindung spät zur Laufzeit auftritt, ist diese Art von Polymorphismus als Laufzeitpolymorphismus oder späte Bindung bekannt.