Interface

In den vorherigen Kapiteln haben wir uns abstrakte Klassen angesehen. Schnittstellen ähneln abstrakten Klassen und teilen die Tatsache, dass keine Instanzen von ihnen erstellt werden können. Schnittstellen sind jedoch noch konzeptueller als abstrakte Klassen, da überhaupt keine Methodenkörper erlaubt sind. Eine Schnittstelle ist also wie eine abstrakte Klasse mit abstrakten Methoden, und da es keine Methoden mit tatsächlichem Code gibt, sind keine Felder erforderlich. Eigenschaften sind jedoch erlaubt, ebenso wie Indexer und Ereignisse. Sie können eine Schnittstelle als Vertrag betrachten - eine Klasse, die sie implementiert, muss alle Methoden und Eigenschaften implementieren. Der wichtigste Unterschied besteht jedoch darin, dass C# zwar keine Mehrfachvererbung zulässt, bei der Klassen mehr als eine einzelne Basisklasse erben, es jedoch die Implementierung mehrerer Schnittstellen ermöglicht!

Also, wie sieht das alles im Code aus? Hier ist ein ziemlich vollständiges Beispiel. Schau es dir an, probiere es vielleicht selbst aus und lies weiter zur vollständigen Erklärung:

using System;
using System.Collections.Generic;

namespace Interfaces
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Dog> dogs = new List<Dog>();
            dogs.Add(new Dog("Fido"));
            dogs.Add(new Dog("Bob"));
            dogs.Add(new Dog("Adam"));
            dogs.Sort();
            foreach(Dog dog in dogs)
                Console.WriteLine(dog.Describe());
            Console.ReadKey();
        }
    }

    interface IAnimal
    {
        string Describe();

        string Name
        {
            get;
            set;
        }
    }

    class Dog : IAnimal, IComparable
    {
        private string name;

        public Dog(string name)
        {
            this.Name = name;
        }

        public string Describe()
        {
            return "Hello, I'm a dog and my name is " + this.Name;
        }

        public int CompareTo(object obj)
        {
            if(obj is IAnimal)
                return this.Name.CompareTo((obj as IAnimal).Name);
            return 0;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

Beginnen wir in der Mitte, wo wir die Schnittstelle deklarieren. Wie Sie sehen können, ist der einzige Unterschied zu einer Klassendeklaration das verwendete Schlüsselwort - interface statt class. Außerdem wird dem Namen der Schnittstelle ein I für Interface vorangestellt - dies ist einfach ein Codierungsstandard und keine Voraussetzung. Sie können Ihre Schnittstellen bezeichnen wie auch immer Sie wollen; weil diese aber, wie Klassen, sehr oft verwendet werden und es Ihnen schwer fallen würde, den Unterschied in einigen Teilen Ihres Codes zu erkennen, ist das I-Präfix ziemlich sinnvoll.

Dann deklarieren wir die "Describe" -Methode und anschließend die "Name" -Eigenschaft, die sowohl ein "get" -Schlüsselwort als auch ein "set" -Schlüsselwort hat, wodurch dies zu einer lesbaren und schreibbaren Eigenschaft wird. Sie werden auch die fehlenden Zugriffsmodifikatoren (öffentlich, privat, geschützt usw.) bemerken, und zwar deshalb, weil sie in einer Schnittstelle nicht erlaubt sind - sie sind standardmäßig alle öffentlich.

Als nächstes ist unsere Hundeklasse dran. Es sieht aus, als würde es von einer anderen Klasse erben, wobei der Doppelpunkt zwischen dem Klassennamen und der Klasse/Schnittstelle unterklassifiziert/implementiert wird. In diesem Fall werden jedoch zwei Schnittstellen für die gleiche Klasse implementiert, die einfach durch ein Komma getrennt sind. Sie können beliebig viele Schnittstellen implementieren, aber in diesem Fall implementieren wir nur zwei - unsere eigene "IAnimal" -Schnittstelle und die .NET "IComparable" -Schnittstelle, bei der es sich um eine gemeinsam genutzte Schnittstelle für sortierbare Klassen handelt. Wie Sie sehen können, haben wir sowohl die Methode und die Eigenschaft von der "IAnimal" -Schnittstelle als auch eine "CompareTo" -Methode von der "IComparable" -Schnittstelle implementiert.

Jetzt könnten Sie denken: Wenn wir die ganze Arbeit selbst machen müssen, indem wir die gesamten Methoden und Eigenschaften implementieren, warum überhaupt diesen Aufwand? Und ein sehr gutes Beispiel dafür, warum es sich lohnt, ist im oberen Teil unseres Beispiels angegeben. Hier fügen wir eine Reihe von Dog-Objekten zu einer Liste hinzu, und dann sortieren wir die Liste. Und warum weiß die Liste wie Hunde sortiert werden? Weil unsere Hundeklasse eine "CompareTo" -Methode hat, die zeigt, wie man zwei Hunde vergleicht. Und woher weiß die Liste, dass unser Dog-Objekt genau das tun kann und welche Methode man anruft, um die Hunde zu vergleichen? Weil wir es so gesagt haben, indem wir eine Schnittstelle implementiert haben, die eine "CompareTo" -Methode verspricht! Das ist die eigentliche Schönheit von Schnittstellen.