In welke gevallen en voor welke doeleinden gebruiken…

Interfaces in C# worden gebruikt om de volgende doelen te bereiken:

Contractdefinitie: Het interface definieert een set leden (methoden, eigenschappen, evenementen, indexers) die een klasse of structuur die dit interface implementeert, moet implementeren. Dit zorgt voor consistentie in het gedrag van verschillende typen.

// Interface-definitie
public interface IDrawable
{
    void Draw();
    int LineThickness { get; set; }
}

// Klasse die het interface implementeert
public class Circle : IDrawable
{
    public int LineThickness { get; set; }

    public void Draw()
    {
        // Logica voor het tekenen van een cirkel
    }
}

Polymorfisme: Het gebruik van interfaces maakt het mogelijk om met objecten van verschillende typen te werken via een gemeenschappelijk interface-type. Dit wordt bereikt doordat elke verwijzing naar een object dat het interface implementeert, kan worden geconverteerd naar dat interface-type.

// Methode die werkt met elk object dat IDrawable implementeert
public void Render(IDrawable item)
{
    item.Draw(); // Roept de concrete implementatie van Draw aan
}

// Gebruik:
IDrawable circle = new Circle();
Render(circle); // De Draw() implementatie van de klasse Circle wordt aangeroepen

Meervoudige overerving: C# ondersteunt geen meervoudige klasse-erfenis, maar een klasse of structuur kan meerdere interfaces implementeren. Dit stelt een type in staat om gedrag te hebben dat in verschillende "contracten" is gedefinieerd.

public interface ISaveable
{
    void Save();
}

public interface ILoadable
{
    void Load();
}

// Klasse die meerdere interfaces implementeert
public class ConfigurationManager : ISaveable, ILoadable
{
    public void Save()
    {
        // Logica voor opslaan
    }

    public void Load()
    {
        // Logica voor laden
    }
}

Decoupling (loskoppeling): Het gebruik van interfaces maakt het mogelijk om de afhankelijkheid tussen componenten te verminderen. In plaats van afhankelijk te zijn van een specifieke klasse, kan een component afhankelijk zijn van een interface. Dit vergemakkelijkt het vervangen van implementaties en testen.

public interface ILogger
{
    void LogMessage(string message);
}

public class FileLogger : ILogger
{
    public void LogMessage(string message)
    {
        // Logica voor het schrijven naar een bestand
    }
}

public class DatabaseLogger : ILogger
{
    public void LogMessage(string message)
    {
        // Logica voor het schrijven naar een database
    }
}

public class ProcessingEngine
{
    private readonly ILogger _logger;

    // Afhankelijkheid van het interface, niet van een concrete implementatie
    public ProcessingEngine(ILogger logger)
    {
        _logger = logger;
    }

    public void ProcessData()
    {
        // ...
        _logger.LogMessage("Gegevens verwerkt.");
    }
}

Uitbreidbaarheid: Interfaces maken het gemakkelijk om nieuwe implementaties van bestaande gedragingen toe te voegen zonder de code te wijzigen die dit interface gebruikt.
Documentatie en zelfdocumentatie: Een goed benoemd interface met opmerkingen bij zijn leden dient als een vorm van documentatie, die beschrijft welk gedrag wordt verwacht van objecten die dit interface implementeren.

In welke gevallen en voor welke doeleinden gebruiken we interfaces in C#?