C# Interfaces Begrijpen: Definitie, Voorbeeld en Praktisch Gebruik

Wat Is Een C# Interface?

Een interface in C# is een contract dat een set leden definieert – methodes, properties, events of indexers – die een class of struct moet implementeren. Het specificeert het wat maar niet het hoe, wat verschillende types in staat stelt dezelfde set operaties bloot te leggen terwijl implementatiedetails verborgen blijven.

Interfaces bevorderen loose coupling, maken polymorfisme mogelijk en ondersteunen meervoudige overerving van typedefinities, wat essentieel is voor het schrijven van testbare, onderhoudbare code.

Concreet Voorbeeld

Hieronder is een minimaal consoleprogramma dat demonstreert hoe een interface gedeclareerd, geïmplementeerd en gebruikt wordt.

using System;
namespace DemoApplication {
    // 1. Declareren van het contract
    interface IGuru99Interface {
        void SetTutorial(int id, string name);
        string GetTutorial();
    }
    // 2. Implementeren van het contract
    class Guru99Tutorial : IGuru99Interface {
        private int tutorialId;
        private string tutorialName;
        public void SetTutorial(int id, string name) {
            tutorialId = id;
            tutorialName = name;
        }
        public string GetTutorial() => tutorialName;
        static void Main(string[] args) {
            var tutor = new Guru99Tutorial();
            tutor.SetTutorial(1, ".Net by Guru99");
            Console.WriteLine(tutor.GetTutorial());
            Console.ReadKey();
        }
    }
}

Belangrijkste punten:

1. Interfaces worden gedeclareerd met het interface trefwoord.
2. Ze bevatten alleen handtekeningen; implementatie wordt geleverd door de class.
3. Een class die een interface implementeert, moet al zijn leden definiëren, wat compliance met het contract garandeert.

Waarom Interfaces Gebruiken?

• Abstractie – Scheid het "wat" van het "hoe".
• Polymorfisme – Behandel verschillende implementaties uniform.
• Testbaarheid – Vervang echte implementaties door mocks of stubs in unittests.

Samenvatting

Een interface specificeert de operaties die een type moet ondersteunen. Door een interface te implementeren, garandeert een class naleving van dat contract, wat schone architectuur en schaalbaar ontwerp faciliteert.