C#-interfaces uitgelegd

Deze gids leidt je door de fundamenten van C#-interfaces, laat zien hoe je ze maakt en implementeert, en benadrukt real-world scenario's waarin ze uitblinken.

Wat is een C#-interface?

Een interface in C# is een contract dat een verzameling methodes, properties, events of indexers definieert zonder enige implementatie te bieden. In tegenstelling tot een abstracte klasse is elk lid van een interface impliciet abstract en public. Hierdoor zijn interfaces ideaal om capabilities te definiëren die meerdere, ongerelateerde klassen kunnen delen.

• Naamconventie: Interfaces krijgen een "I" als prefix (bijv. IPolygon) om hun doel direct duidelijk te maken.
• Toegangsmodifiers: Leden mogen binnen een interface geen toegangsmodifiers hebben; ze zijn altijd public.
• Geen velden: Interfaces kunnen geen velden declareren.

interface IPolygon { void CalculateArea(); }

Een interface implementeren

Om een interface te gebruiken, moet een klasse deze implementeren door concrete definities te bieden voor al zijn leden. De dubbele punt-syntaxis (:) wordt gebruikt, net als bij overerving.

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($"Area of Rectangle: {area}"); } } class Program { static void Main(string[] args) { Rectangle rect = new Rectangle(); rect.CalculateArea(100, 200); } } }

Output

Area of Rectangle: 20000

Meerdere interfaces implementeren

C# stelt een klasse in staat om meerdere interfaces tegelijkertijd te implementeren, wat multiple inheritance van types mogelijk maakt.

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($"Area of Rectangle: {area}"); } public void GetColor() { Console.WriteLine("Red Rectangle"); } } class Program { static void Main(string[] args) { Rectangle r = new Rectangle(); r.CalculateArea(100, 200); r.GetColor(); } } }

Output

Area of Rectangle: 20000 Red Rectangle

Een interface-referentie gebruiken

Hoewel je een interface niet direct kunt instantiëren, kun je wel een variabele van dat interface-type declareren en een instantie van een implementerende klasse eraan toewijzen. Dit is een krachtig hulpmiddel om polymorfisme te bereiken.

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($"Area of Rectangle: {area}"); } } class Program { static void Main(string[] args) { IPolygon poly = new Rectangle(); poly.CalculateArea(100, 200); } } }

Output

Area of Rectangle: 20000

Praktisch voorbeeld: polymorfe vormberekeningen

Hieronder definieren we een IPolygon-interface en twee concrete vormen die deze implementeren. Elke vorm berekent zijn oppervlakte onafhankelijk.

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($"Area of Rectangle: {area}"); } } class Square : IPolygon { public void CalculateArea() { int side = 30; int area = side * side; Console.WriteLine($"Area of Square: {area}"); } } class Program { static void Main(string[] args) { Rectangle rect = new Rectangle(); rect.CalculateArea(); Square sq = new Square(); sq.CalculateArea(); } } }

Output

Area of Rectangle: 2700 Area of Square: 900

Waarom C#-interfaces gebruiken?

• Abstraktie: Ze definiëren een contract zonder implementatie voor te schrijven, zodat developers zich kunnen richten op wat een klasse moet doen in plaats van hoe.
• Specificatie: Elke klasse die een interface implementeert, garandeert dat de gedeclareerde methodes worden geleverd, wat consistentie in de codebase waarborgt.
• Multiple inheritance: Omdat C# geen multiple class inheritance ondersteunt, vullen interfaces het gat door een klasse meerdere capabilities te laten aannemen.
• Losse koppeling: Code die afhankelijk is van een interface in plaats van een concrete klasse is flexibeler en eenvoudiger te onderhouden of te testen.