C#-Interfaces meistern: Definition, Implementierung und praktische Anwendungsfälle

C#-Interfaces erklärt

Dieser Leitfaden führt Sie durch die Grundlagen von C#-Interfaces, zeigt deren Erstellung und Implementierung und beleuchtet reale Szenarien, in denen sie glänzen.

Was ist ein C#-Interface?

Ein Interface in C# ist ein Vertrag, der eine Menge von Methoden, Eigenschaften, Ereignissen oder Indexern definiert, ohne eine Implementierung bereitzustellen. Im Gegensatz zu einer abstrakten Klasse ist jedes Mitglied eines Interfaces implizit abstrakt und public. Daher eignen sich Interfaces ideal, um Fähigkeiten zu definieren, die mehrere, nicht verwandte Klassen gemeinsam nutzen können.

• Namenskonvention: Interfaces werden mit einem „I“ präfixiert (z. B. IPolygon), um ihren Zweck auf einen Blick erkennbar zu machen.
• Zugriffsmodifizierer: Mitglieder können innerhalb eines Interfaces keine Zugriffsmodifizierer haben; sie sind immer public.
• Keine Felder: Interfaces können keine Felder deklarieren.

interface IPolygon { void CalculateArea(); }

Ein Interface implementieren

Um ein Interface zu verwenden, muss eine Klasse es implementieren, indem sie konkrete Definitionen für alle seine Mitglieder bereitstellt. Die Doppelpunkt-Syntax (:) wird verwendet, genau wie bei Vererbung.

using System;

namespace CsharpInterface
{
    interface IPolygon
    {
        void CalculateArea(int length, int breadth);
    }

    class Rectangle : IPolygon
    {
        public void CalculateArea(int length, int breadth)
        {
            int area = length * breadth;
            Console.WriteLine($"Fläche des Rechtecks: {area}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Rectangle rect = new Rectangle();
            rect.CalculateArea(100, 200);
        }
    }
}

Ausgabe

Fläche des Rechtecks: 20000

Mehrere Interfaces implementieren

C# erlaubt einer Klasse, mehrere Interfaces gleichzeitig zu implementieren, was eine Mehrfachvererbung von Typen ermöglicht.

using System;

namespace CsharpInterface
{
    interface IPolygon
    {
        void CalculateArea(int a, int b);
    }

    interface IColor
    {
        void GetColor();
    }

    class Rectangle : IPolygon, IColor
    {
        public void CalculateArea(int a, int b)
        {
            int area = a * b;
            Console.WriteLine($"Fläche des Rechtecks: {area}");
        }

        public void GetColor()
        {
            Console.WriteLine("Rotes Rechteck");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.CalculateArea(100, 200);
            r.GetColor();
        }
    }
}

Ausgabe

Fläche des Rechtecks: 20000 Rotes Rechteck

Eine Interface-Referenz verwenden

Obwohl man ein Interface nicht direkt instanziieren kann, kann man eine Variable dieses Interface-Typs deklarieren und ihr eine Instanz einer beliebigen implementierenden Klasse zuweisen. Dies ist ein mächtiges Werkzeug zur Erreichung von Polymorphie.

using System;

namespace CsharpInterface
{
    interface IPolygon
    {
        void CalculateArea(int length, int breadth);
    }

    class Rectangle : IPolygon
    {
        public void CalculateArea(int length, int breadth)
        {
            int area = length * breadth;
            Console.WriteLine($"Fläche des Rechtecks: {area}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IPolygon poly = new Rectangle();
            poly.CalculateArea(100, 200);
        }
    }
}

Ausgabe

Fläche des Rechtecks: 20000

Praktisches Beispiel: Polymorphe Flächenberechnungen

Im Folgenden definieren wir ein IPolygon-Interface und zwei konkrete Formen, die es implementieren. Jede Form berechnet ihre Fläche unabhängig.

using System;

namespace CsharpInterface
{
    interface IPolygon
    {
        void CalculateArea();
    }

    class Rectangle : IPolygon
    {
        public void CalculateArea()
        {
            int length = 30;
            int breadth = 90;
            int area = length * breadth;
            Console.WriteLine($"Fläche des Rechtecks: {area}");
        }
    }

    class Square : IPolygon
    {
        public void CalculateArea()
        {
            int side = 30;
            int area = side * side;
            Console.WriteLine($"Fläche des Quadrats: {area}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Rectangle rect = new Rectangle();
            rect.CalculateArea();

            Square sq = new Square();
            sq.CalculateArea();
        }
    }
}

Ausgabe

Fläche des Rechtecks: 2700 Fläche des Quadrats: 900

Warum C#-Interfaces verwenden?

• Abstraktion: Sie definieren einen Vertrag ohne Implementierungsvorgaben, sodass Entwickler sich auf was eine Klasse tun soll konzentrieren können, statt auf wie.
• Spezifikation: Jede Klasse, die ein Interface implementiert, garantiert die Bereitstellung der deklarierten Methoden, was Konsistenz im Codebase sicherstellt.
• Mehrfachvererbung: Da C# keine Mehrfachvererbung von Klassen unterstützt, schließen Interfaces diese Lücke, indem sie einer Klasse erlauben, mehrere Fähigkeiten anzunehmen.
• Lose Kopplung: Code, der von einem Interface statt von einer konkreten Klasse abhängt, ist flexibler und einfacher zu warten oder zu testen.